Index: libcxx/include/concepts
===================================================================
--- libcxx/include/concepts
+++ libcxx/include/concepts
@@ -163,6 +163,20 @@
 concept derived_from =
   __is_base_of(_Bp, _Dp) && __is_convertible_to(const volatile _Dp*, const volatile _Bp*);
 
+// [concepts.arithmetic]
+
+template<class _Tp>
+concept integral = __is_integral(_Tp);
+
+template<class _Tp>
+concept signed_integral = integral<_Tp> && __is_signed(_Tp);
+
+template<class _Tp>
+concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
+
+template<class _Tp>
+concept floating_point = __is_floating_point(_Tp);
+
 #endif //_LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
 
 _LIBCPP_END_NAMESPACE_STD
Index: libcxx/test/std/concepts/lang/arithmetic.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/concepts/lang/arithmetic.pass.cpp
@@ -0,0 +1,386 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T>
+// concept integral = // see below
+
+// template<class T>
+// concept signed_integral = // see below
+
+// template<class T>
+// concept unsigned_integral = // see below
+
+// template<class T>
+// concept floating_point = // see below
+
+#include <concepts>
+#include <type_traits>
+
+namespace {
+constexpr void CheckIntegral() {
+  // conventional integral types
+  static_assert(std::integral<signed char>);
+  static_assert(std::integral<unsigned char>);
+  static_assert(std::integral<short>);
+  static_assert(std::integral<unsigned short>);
+  static_assert(std::integral<int>);
+  static_assert(std::integral<unsigned int>);
+  static_assert(std::integral<long>);
+  static_assert(std::integral<unsigned long>);
+  static_assert(std::integral<long long>);
+  static_assert(std::integral<unsigned long long>);
+  static_assert(std::integral<const int>);
+  static_assert(std::integral<volatile int>);
+  static_assert(std::integral<const volatile int>);
+
+  // integrals that mightn't necessarily be expected as integral
+  static_assert(std::integral<wchar_t>);
+  static_assert(std::integral<bool>);
+  static_assert(std::integral<char>);
+  static_assert(std::integral<char8_t>);
+  static_assert(std::integral<char16_t>);
+  static_assert(std::integral<char32_t>);
+
+  // types that aren't integral
+  static_assert(!std::integral<void>);
+  static_assert(!std::integral<float>);
+  static_assert(!std::integral<double>);
+  static_assert(!std::integral<long double>);
+  static_assert(!std::integral<int*>);
+  static_assert(!std::integral<const char*>);
+  static_assert(!std::integral<short&>);
+  static_assert(!std::integral<const long&>);
+  static_assert(!std::integral<unsigned long long&&>);
+  static_assert(!std::integral<int (*)()>);
+  static_assert(!std::integral<double (*)(int)>);
+  static_assert(!std::integral<double (&)(int)>);
+
+  enum ClassicEnum { a, b, c };
+  static_assert(!std::integral<ClassicEnum>);
+
+  enum class ScopedEnum { x, y, z };
+  static_assert(!std::integral<ScopedEnum>);
+
+  struct EmptyStruct {};
+  static_assert(!std::integral<EmptyStruct>);
+
+  struct WithMember {
+    int Sneaky;
+  };
+  static_assert(!std::integral<WithMember>);
+  static_assert(!std::integral<int WithMember::*>);
+
+  struct WithMemberFunction {
+    int Sneaky();
+  };
+  static_assert(!std::integral<int (WithMemberFunction::*)()>);
+
+  struct WithConstMemFunc {
+    int Sneaky() const;
+  };
+  static_assert(!std::integral<int (WithConstMemFunc::*)()>);
+
+  struct WithLvalMemberFunction {
+    int Sneaky() &;
+  };
+  static_assert(!std::integral<int (WithLvalMemberFunction::*)()>);
+
+  struct WithLvalConstMemFunc {
+    int Sneaky() const&;
+  };
+  static_assert(!std::integral<int (WithLvalConstMemFunc::*)()>);
+
+  struct WithRvalMemberFunction {
+    int Sneaky() &&;
+  };
+  static_assert(!std::integral<int (WithRvalMemberFunction::*)()>);
+
+  struct WithRvalConstMemFunc {
+    int Sneaky() const&&;
+  };
+  static_assert(!std::integral<int (WithRvalConstMemFunc::*)()>);
+}
+
+constexpr void CheckSignedIntegral() {
+  // conventional signed integral types
+  static_assert(std::signed_integral<signed char>);
+  static_assert(std::signed_integral<short>);
+  static_assert(std::signed_integral<int>);
+  static_assert(std::signed_integral<long>);
+  static_assert(std::signed_integral<long long>);
+  static_assert(std::signed_integral<const int>);
+  static_assert(std::signed_integral<volatile int>);
+  static_assert(std::signed_integral<const volatile int>);
+
+  // integrals that mightn't necessarily be expected as signed integral
+  static_assert(std::signed_integral<wchar_t> == std::is_signed_v<wchar_t>);
+  static_assert(std::signed_integral<bool> == std::is_signed_v<bool>);
+  static_assert(std::signed_integral<char> == std::is_signed_v<char>);
+  static_assert(std::signed_integral<char8_t> == std::is_signed_v<char8_t>);
+  static_assert(std::signed_integral<char16_t> == std::is_signed_v<char16_t>);
+  static_assert(std::signed_integral<char32_t> == std::is_signed_v<char32_t>);
+
+  // types that aren't signed integrals
+  static_assert(!std::signed_integral<unsigned char>);
+  static_assert(!std::signed_integral<unsigned short>);
+  static_assert(!std::signed_integral<unsigned int>);
+  static_assert(!std::signed_integral<unsigned long>);
+  static_assert(!std::signed_integral<unsigned long long>);
+  static_assert(!std::signed_integral<const unsigned long long>);
+  static_assert(!std::signed_integral<volatile unsigned long>);
+  static_assert(!std::signed_integral<const volatile unsigned int>);
+
+  static_assert(!std::signed_integral<void>);
+  static_assert(!std::signed_integral<float>);
+  static_assert(!std::signed_integral<double>);
+  static_assert(!std::signed_integral<long double>);
+  static_assert(!std::signed_integral<int*>);
+  static_assert(!std::signed_integral<const char*>);
+  static_assert(!std::signed_integral<short&>);
+  static_assert(!std::signed_integral<const long&>);
+  static_assert(!std::signed_integral<unsigned long long&&>);
+  static_assert(!std::signed_integral<int (*)()>);
+  static_assert(!std::signed_integral<double (*)(int)>);
+  static_assert(!std::signed_integral<double (&)(int)>);
+
+  enum ClassicEnum { a, b, c };
+  static_assert(!std::signed_integral<ClassicEnum>);
+
+  enum class ScopedEnum { x, y, z };
+  static_assert(!std::signed_integral<ScopedEnum>);
+
+  struct EmptyStruct {};
+  static_assert(!std::signed_integral<EmptyStruct>);
+
+  struct WithMember {
+    int Sneaky;
+  };
+  static_assert(!std::signed_integral<WithMember>);
+  static_assert(!std::signed_integral<int WithMember::*>);
+
+  struct WithMemberFunction {
+    int Sneaky();
+  };
+  static_assert(!std::signed_integral<int (WithMemberFunction::*)()>);
+
+  struct WithConstMemFunc {
+    int Sneaky() const;
+  };
+  static_assert(!std::signed_integral<int (WithConstMemFunc::*)()>);
+
+  struct WithLvalMemberFunction {
+    int Sneaky() &;
+  };
+  static_assert(!std::signed_integral<int (WithLvalMemberFunction::*)()>);
+
+  struct WithLvalConstMemFunc {
+    int Sneaky() const&;
+  };
+  static_assert(!std::signed_integral<int (WithLvalConstMemFunc::*)()>);
+
+  struct WithRvalMemberFunction {
+    int Sneaky() &&;
+  };
+  static_assert(!std::signed_integral<int (WithRvalMemberFunction::*)()>);
+
+  struct WithRvalConstMemFunc {
+    int Sneaky() const&&;
+  };
+  static_assert(!std::signed_integral<int (WithRvalConstMemFunc::*)()>);
+}
+
+constexpr void CheckUnsignedIntegral() {
+  // conventional unsigned integral types
+  static_assert(std::unsigned_integral<unsigned char>);
+  static_assert(std::unsigned_integral<unsigned short>);
+  static_assert(std::unsigned_integral<unsigned int>);
+  static_assert(std::unsigned_integral<unsigned long>);
+  static_assert(std::unsigned_integral<unsigned long long>);
+  static_assert(std::unsigned_integral<const unsigned long long>);
+  static_assert(std::unsigned_integral<volatile unsigned long>);
+  static_assert(std::unsigned_integral<const volatile unsigned int>);
+
+  // integrals that mightn't necessarily be expected as unsigned integral
+  static_assert(std::unsigned_integral<wchar_t> == !std::is_signed_v<wchar_t>);
+  static_assert(std::unsigned_integral<bool> == !std::is_signed_v<bool>);
+  static_assert(std::unsigned_integral<char> == !std::is_signed_v<char>);
+  static_assert(std::unsigned_integral<char8_t> == !std::is_signed_v<char8_t>);
+  static_assert(std::unsigned_integral<char16_t> ==
+                !std::is_signed_v<char16_t>);
+  static_assert(std::unsigned_integral<char32_t> ==
+                !std::is_signed_v<char32_t>);
+
+  // types that aren't unsigned integrals
+  static_assert(!std::unsigned_integral<signed char>);
+  static_assert(!std::unsigned_integral<short>);
+  static_assert(!std::unsigned_integral<int>);
+  static_assert(!std::unsigned_integral<long>);
+  static_assert(!std::unsigned_integral<long long>);
+  static_assert(!std::unsigned_integral<const int>);
+  static_assert(!std::unsigned_integral<volatile int>);
+  static_assert(!std::unsigned_integral<const volatile int>);
+
+  static_assert(!std::unsigned_integral<void>);
+  static_assert(!std::unsigned_integral<float>);
+  static_assert(!std::unsigned_integral<double>);
+  static_assert(!std::unsigned_integral<long double>);
+  static_assert(!std::unsigned_integral<unsigned int*>);
+  static_assert(!std::unsigned_integral<const char*>);
+  static_assert(!std::unsigned_integral<unsigned short&>);
+  static_assert(!std::unsigned_integral<const long&>);
+  static_assert(!std::unsigned_integral<unsigned long long&&>);
+  static_assert(!std::unsigned_integral<int (*)()>);
+  static_assert(!std::unsigned_integral<double (*)(int)>);
+  static_assert(!std::unsigned_integral<double (&)(int)>);
+
+  enum ClassicEnum { a, b, c };
+  static_assert(!std::unsigned_integral<ClassicEnum>);
+
+  enum class ScopedEnum { x, y, z };
+  static_assert(!std::unsigned_integral<ScopedEnum>);
+
+  struct EmptyStruct {};
+  static_assert(!std::unsigned_integral<EmptyStruct>);
+
+  struct WithMember {
+    int Sneaky;
+  };
+  static_assert(!std::unsigned_integral<WithMember>);
+  static_assert(!std::unsigned_integral<int WithMember::*>);
+
+  struct WithMemberFunction {
+    int Sneaky();
+  };
+  static_assert(!std::unsigned_integral<int (WithMemberFunction::*)()>);
+
+  struct WithConstMemFunc {
+    int Sneaky() const;
+  };
+  static_assert(!std::unsigned_integral<int (WithConstMemFunc::*)()>);
+
+  struct WithLvalMemberFunction {
+    int Sneaky() &;
+  };
+  static_assert(!std::unsigned_integral<int (WithLvalMemberFunction::*)()>);
+
+  struct WithLvalConstMemFunc {
+    int Sneaky() const&;
+  };
+  static_assert(!std::unsigned_integral<int (WithLvalConstMemFunc::*)()>);
+
+  struct WithRvalMemberFunction {
+    int Sneaky() &&;
+  };
+  static_assert(!std::unsigned_integral<int (WithRvalMemberFunction::*)()>);
+
+  struct WithRvalConstMemFunc {
+    int Sneaky() const&&;
+  };
+  static_assert(!std::unsigned_integral<int (WithRvalConstMemFunc::*)()>);
+}
+
+constexpr void CheckFloatingPoint() {
+  // floating-point types
+  static_assert(std::floating_point<float>);
+  static_assert(std::floating_point<double>);
+  static_assert(std::floating_point<long double>);
+  static_assert(std::floating_point<const float>);
+  static_assert(std::floating_point<volatile double>);
+  static_assert(std::floating_point<const volatile long double>);
+
+  // types that aren't floating-point
+  static_assert(!std::floating_point<signed char>);
+  static_assert(!std::floating_point<unsigned char>);
+  static_assert(!std::floating_point<short>);
+  static_assert(!std::floating_point<unsigned short>);
+  static_assert(!std::floating_point<int>);
+  static_assert(!std::floating_point<unsigned int>);
+  static_assert(!std::floating_point<long>);
+  static_assert(!std::floating_point<unsigned long>);
+  static_assert(!std::floating_point<long long>);
+  static_assert(!std::floating_point<unsigned long long>);
+  static_assert(!std::floating_point<const unsigned long long>);
+  static_assert(!std::floating_point<volatile unsigned long>);
+  static_assert(!std::floating_point<const volatile unsigned int>);
+  static_assert(!std::floating_point<wchar_t>);
+  static_assert(!std::floating_point<bool>);
+  static_assert(!std::floating_point<char>);
+  static_assert(!std::floating_point<char8_t>);
+  static_assert(!std::floating_point<char16_t>);
+  static_assert(!std::floating_point<char32_t>);
+  static_assert(!std::floating_point<const int>);
+  static_assert(!std::floating_point<volatile int>);
+  static_assert(!std::floating_point<const volatile int>);
+
+  static_assert(!std::floating_point<void>);
+  static_assert(!std::floating_point<double*>);
+  static_assert(!std::floating_point<const char*>);
+  static_assert(!std::floating_point<float&>);
+  static_assert(!std::floating_point<const long&>);
+  static_assert(!std::floating_point<unsigned long long&&>);
+  static_assert(!std::floating_point<int (*)()>);
+  static_assert(!std::floating_point<double (*)(int)>);
+  static_assert(!std::floating_point<double (&)(int)>);
+
+  enum ClassicEnum { a, b, c };
+  static_assert(!std::floating_point<ClassicEnum>);
+
+  enum class ScopedEnum { x, y, z };
+  static_assert(!std::floating_point<ScopedEnum>);
+
+  struct EmptyStruct {};
+  static_assert(!std::floating_point<EmptyStruct>);
+
+  struct WithMember {
+    int Sneaky;
+  };
+  static_assert(!std::floating_point<WithMember>);
+  static_assert(!std::floating_point<int WithMember::*>);
+
+  struct WithMemberFunction {
+    int Sneaky();
+  };
+  static_assert(!std::floating_point<int (WithMemberFunction::*)()>);
+
+  struct WithConstMemFunc {
+    int Sneaky() const;
+  };
+  static_assert(!std::floating_point<int (WithConstMemFunc::*)()>);
+
+  struct WithLvalMemberFunction {
+    int Sneaky() &;
+  };
+  static_assert(!std::floating_point<int (WithLvalMemberFunction::*)()>);
+
+  struct WithLvalConstMemFunc {
+    int Sneaky() const&;
+  };
+  static_assert(!std::floating_point<int (WithLvalConstMemFunc::*)()>);
+
+  struct WithRvalMemberFunction {
+    int Sneaky() &&;
+  };
+  static_assert(!std::floating_point<int (WithRvalMemberFunction::*)()>);
+
+  struct WithRvalConstMemFunc {
+    int Sneaky() const&&;
+  };
+  static_assert(!std::floating_point<int (WithRvalConstMemFunc::*)()>);
+}
+} // namespace
+
+int main(int, char**) {
+  CheckIntegral();
+  CheckSignedIntegral();
+  CheckUnsignedIntegral();
+  CheckFloatingPoint();
+  return 0;
+}