Script Programming(스크립트 프로그래밍)

tommath library 사용하여 g++, gcc, cl, clang-cl, clang++ 등으로 컴파일 할 때, 에러메시지 해결하기

Scripter — Sun, 3 May 2026 14:12:48 +0900

[1] 테스트용 소스 파일 test_main.cpp 의 내용:

#include <tommath.h>
#include <stdio.h>

int main() {
    mp_int num;
    mp_init(&num);
    mp_set_int(&num, 12345);
    printf("Number: %d\n", mp_get_int(&num));
    mp_clear(&num);
    return 0;
}

[2] 컴파일하기:

$ g++ test_main.cpp -o test_main -ltommath
test_main .cpp: In function 'int main()':
test_main .cpp:7:15: warning: 'mp_err mp_set_int(mp_int*, long unsigned int)' is deprecated: replaced by mp_set_ul [-Wdeprecated-declarations]
    7 |     mp_set_int(&num, 12345);
      |     ~~~~~~~~~~^~~~~~~~~~~~~
In file included from test_tommath_cpp_001.cpp:1:
include/tommath.h:359:33: note: declared here
  359 | MP_DEPRECATED(mp_set_ul) mp_err mp_set_int(mp_int *a, unsigned long b);
      |                                 ^~~~~~~~~~
test_tommath_cpp_001.cpp:8:38: warning: 'long unsigned int mp_get_int(const mp_int*)' is deprecated: replaced by mp_get_mag_u32/mp_get_u32 [-Wdeprecated-declarations]
    8 |     printf("Number: %d\n", mp_get_int(&num));
      |                            ~~~~~~~~~~^~~~~~
include/tommath.h:356:56: note: declared here
  356 | MP_DEPRECATED(mp_get_mag_u32/mp_get_u32) unsigned long mp_get_int(const mp_int *a) MP_WUR;
      |                                                        ^~~~~~~~~~
test_tommath_cpp_001.cpp:6:12: warning: ignoring return value of 'mp_err mp_init(mp_int*)' declared with attribute 'warn_unused_result' [-Wunused-result]
    6 |     mp_init(&num);
      |     ~~~~~~~^~~~~~

[3] 수정된 소스 파일 test_main.cpp 의 내용:

#include <stdio.h>
#include <tommath.h>

int main() {
    mp_int num;
    mp_err err_n = mp_init(&num);
    mp_set_i32(&num, 12345);   // <==  mp_set_int(&num, 12345);
    printf("Number: %d\n", mp_get_i32(&num));  // <== printf("Number: %d\n", mp_get_int(&num));
    mp_clear(&num);
    return 0;
}

[4] 수정된 소스 파일 test_main.cpp 컴파일하기:

$ g++ test_main.cpp -o test_main -ltommath

[5] 생성된 실핼파일 test_main 을 실행한 결과 :

$ ./test_main
Number: 12345

g++ 컴파일러로 int128 정수와 float128 부동소수점수 사용하기

Scripter — Mon, 12 May 2025 14:18:20 +0900

소스 파일명 : int128_example.cpp

* 수정 전의 원본 소스는 여기서 구할 수 있습니다.

컴파일하기

$ g++ -o int128_example int128_example.cpp -fexceptions -std=gnu++17 -g -fext-numeric-literals -fpermissive -lquadmath

int128 정수(128비트 부호 있는 정수) 사용하는 예제

#include <quadmath.h>
#include <stdlib.h>
#include <stdio.h>

int main ()
{
  __float128 r;
  int prec = 20;
  int width = 46;
  char buf[128];

  r = 2.0q;
  r = sqrtq (r);
  int n = quadmath_snprintf (buf, sizeof buf, "%+-#*.20Qe", width, r);
  if ((size_t) n < sizeof buf)
    printf ("%s\n", buf);
    /* Prints: +1.41421356237309504880e+00 */
  quadmath_snprintf (buf, sizeof buf, "%Qa", r);
  if ((size_t) n < sizeof buf)
    printf ("%s\n", buf);
    /* Prints: 0x1.6a09e667f3bcc908b2fb1366ea96p+0 */
  n = quadmath_snprintf (NULL, 0, "%+-#46.*Qe", prec, r);
  if (n > -1)
    {
      char *str = (char *) malloc (n + 1);
      if (str)
        {
          quadmath_snprintf (str, n + 1, "%+-#46.*Qe", prec, r);
          printf ("%s\n", str);
          /* Prints: +1.41421356237309504880e+00 */
        }
      free (str);
    }
  return 0;
}

float128 부동소수점수(128비트 부동소수점수 ) 사용하는 예제

* 소스 파일명 : float128_example.cpp

* 수정 전의 원본 소스는 여기서

224행. 225행, 226행

//std::cout << tifu128.name() << std::endl; // On GCC, aborts (because not printable string).
//std::cout << typeid(__float128).name() << std::endl; // Aborts -
// string name cannot be output.

을 아래의 두 행으로 바꾸고

std::cout << " tifu128.name() = " << tifu128.name() << std::endl;
std::cout << " typeid(__float128).name() = " << typeid(__float128).name() << std::endl;

아래 처럼 g++ 컴파일 명령으로 컴파일하면 (경고 없이) 컴파일됩니다.

* 컴파일하기

$ g++ -o float128_example.exe float128_example.cpp -I$BOOST_PATH -fexceptions -std=gnu++17 -g -fext-numeric-literals -fpermissive -lquadmath -Wunused-variable

//  Copyright John Maddock 2016
//  Copyright Christopher Kormanyos 2016.
//  Copyright Paul A. Bristow 2016.

//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// Contains Quickbook snippets as C++ comments - do not remove.

// http://gcc.gnu.org/onlinedocs/libquadmath/ GCC Quad-Precision Math Library
// https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format

// https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Dialect-Options.html#C_002b_002b-Dialect-Options GNU 3.5 Options Controlling C++ Dialect
// https://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html#C-Dialect-Options 3.4 Options Controlling C Dialect

//[float128_includes_1

#include <boost/cstdfloat.hpp> // For float_64_t, float128_t. Must be first include!
//#include <boost/config.hpp>
#include <boost/multiprecision/float128.hpp>
#include <boost/math/special_functions.hpp> // For gamma function.
#include <boost/math/constants/constants.hpp> // For constants pi, e ...
#include <typeinfo> //

#include <cmath>  // for pow function.

// #include <quadmath.h>
// C:\program files\gcc-6-win64\lib\gcc\x86_64-w64-mingw32\6.1.1\include\quadmath.h

// i:\modular-boost\boost\multiprecision\float128.hpp|210|  undefined reference to `quadmath_snprintf'.

//] [/float128_includes_1]

//[float128_dialect_1
/*`To make float128 available it is vital to get the dialect and options on the command line correct.

Quad type is forbidden by all the strict C++ standards, so using or adding -std=c++11 and later standards will prevent its use.
so explicitly use -std=gnu++11, 1y, 14, 17, or 1z or ...

For GCC 6.1.1, for example, the default is if no C++ language dialect options are given, is -std=gnu++14.

See https://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html#C-Dialect-Options
https://gcc.gnu.org/onlinedocs/gcc/Standards.html#Standards 2 Language Standards Supported by GCC

 g++.exe -Wall -fexceptions -std=gnu++17 -g -fext-numeric-literals -fpermissive -lquadmath
  -II:\modular-boost\libs\math\include -Ii:\modular-boost -c J:\Cpp\float128\float128\float128_example.cpp -o obj\Debug\float128_example.o

Requires GCC linker option -lquadmath

If this is missing, then get errors like:

  \modular-boost\boost\multiprecision\float128.hpp|210|undefined reference to `quadmath_snprintf'|
  \modular-boost\boost\multiprecision\float128.hpp|351|undefined reference to `sqrtq'|

Requires compile option

  -fext-numeric-literals

If missing, then get errors like:

\modular-boost\libs\math\include/boost/math/cstdfloat/cstdfloat_types.hpp:229:43: error: unable to find numeric literal operator 'operator""Q'

A successful build log was:

  g++.exe -Wall -std=c++11 -fexceptions -std=gnu++17 -g -fext-numeric-literals -II:\modular-boost\libs\math\include -Ii:\modular-boost -c J:\Cpp\float128\float128\float128_example.cpp -o obj\Debug\float128_example.o
  g++.exe  -o bin\Debug\float128.exe obj\Debug\float128_example.o  -lquadmath
*/

//] [/float128_dialect_1]

void show_versions(std::string title)
{
  std::cout << title << std::endl;

  std::cout << "Platform: " << BOOST_PLATFORM << '\n'
    << "Compiler: " << BOOST_COMPILER << '\n'
    << "STL     : " << BOOST_STDLIB << '\n'
    << "Boost   : " << BOOST_VERSION / 100000 << "."
    << BOOST_VERSION / 100 % 1000 << "."
    << BOOST_VERSION % 100
    << std::endl;
#ifdef _MSC_VER
  std::cout << "_MSC_FULL_VER = " << _MSC_FULL_VER << std::endl; // VS 2015 190023026
#if defined _M_IX86
  std::cout << "(x86)" << std::endl;
#endif
#if defined _M_X64
  std::cout << " (x64)" << std::endl;
#endif
#if defined _M_IA64
  std::cout << " (Itanium)" << std::endl;
#endif
  // Something very wrong if more than one is defined (so show them in all just in case)!
#endif // _MSC_VER
#ifdef __GNUC__
//PRINT_MACRO(__GNUC__);
//PRINT_MACRO(__GNUC_MINOR__);
//PRINT_MACRO(__GNUC_PATCH__);
std::cout << "GCC " << __VERSION__  << std::endl;
//PRINT_MACRO(LONG_MAX);
#endif // __GNUC__
  return;
} // void show_version(std::string title)

int main()
{
  try
  {

//[float128_example_3
// Always use try'n'catch blocks to ensure any error messages are displayed.
//`Ensure that all possibly significant digits (17) including trailing zeros are shown.

    std::cout.precision(std::numeric_limits<boost::float64_t>::max_digits10);
    std::cout.setf(std::ios::showpoint); // Show all significant trailing zeros.
 //] [/ float128_example_3]

#ifdef BOOST_FLOAT128_C
  std::cout << "Floating-point type boost::float128_t is available." << std::endl;
    std::cout << "  std::numeric_limits<boost::float128_t>::digits10 == "
    << std::numeric_limits<boost::float128_t>::digits10 << std::endl;
  std::cout << "  std::numeric_limits<boost::float128_t>::max_digits10 == "
    << std::numeric_limits<boost::float128_t>::max_digits10 << std::endl;
#else
  std::cout << "Floating-point type boost::float128_t is NOT available." << std::endl;
#endif

  show_versions("");

  using boost::multiprecision::float128;  // Wraps, for example, __float128 or _Quad.
  // or
  //using namespace boost::multiprecision;

  std::cout.precision(std::numeric_limits<float128>::max_digits10);  // Show all potentially meaningful digits.
  std::cout.setf(std::ios::showpoint); // Show all significant trailing zeros.

  // float128 pi0 = boost::math::constants::pi(); // Compile fails - need to specify a type for the constant!

  float128 pi1 = boost::math::constants::pi<float128>();  // Returns a constant of type float128.
  std::cout << sqrt(pi1) << std::endl; // 1.77245385090551602729816748334114514

  float128 pi2 = boost::math::constants::pi<__float128>(); // Constant of type __float128 gets converted to float128 on the assignment.
  std::cout << sqrt(pi2) << std::endl; // 1.77245385090551602729816748334114514

  // DIY decimal digit literal constant, with suffix Q.
  float128 pi3 = 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348Q;
  std::cout << sqrt(pi3) << std::endl; // 1.77245385090551602729816748334114514

  // Compare to ready-rolled sqrt(pi) constant from Boost.Math:
  std::cout << boost::math::constants::root_pi<float128>() << std::endl; // 1.77245385090551602729816748334114514

   // DIY decimal digit literal constant, without suffix Q, suffering seventeen silent digits loss of precision!
  float128 pi4 = 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348;
  std::cout << sqrt(pi4) << std::endl; // 1.77245385090551599275151910313924857

  // float128 variables constructed from a quad-type literal can be declared constexpr if required:

#ifndef BOOST_NO_CXX11_CONSTEXPR
  constexpr float128 pi_constexpr = 3.1415926535897932384626433832795028841971693993751058Q;
#endif
  std::cout << pi_constexpr << std::endl; // 3.14159265358979323846264338327950280

  // But sadly functions like sqrt are not yet available constexpr for float128.

  // constexpr float128 root_pi_constexpr = sqrt(pi_constexpr);  // Fails - not constexpr (yet).
  // constexpr float128 root_pi_constexpr = std::sqrt(pi_constexpr);  // Fails - no known conversion for argument 1 from 'const float128'.
  // constexpr float128 root_pi_constexpr = sqrt(pi_constexpr); // Call to non-constexpr
  // constexpr float128 root_pi_constexpr = boost::math::constants::root_pi(); // Missing type for constant.

  // Best current way to get a constexpr is to use a Boost.Math constant if one is available.
  constexpr float128 root_pi_constexpr = boost::math::constants::root_pi<float128>();
  std::cout << root_pi_constexpr << std::endl; // 1.77245385090551602729816748334114514

  // Note that casts within the sqrt call are NOT NEEDED (nor allowed),
  // since all the variables are the correct type to begin with.
  // std::cout << sqrt<float128>(pi3) << std::endl;
  // But note examples of catastrophic (but hard to see) loss of precision below.

  // Note also that the library functions, here sqrt, is NOT defined using std::sqrt,
  // so that the correct overload is found using Argument Dependent LookUp (ADL).

  float128 ee = boost::math::constants::e<float128>();
   std::cout << ee << std::endl;  // 2.71828182845904523536028747135266231

  float128 e1 = exp(1.Q); // Note argument to exp is type float128.
  std::cout << e1 << std::endl; // 2.71828182845904523536028747135266231

  // Beware - it is all too easy to silently get a much lower precision by mistake.

  float128 e1d = exp(1.); // Caution - only double 17 decimal digits precision!
  std::cout << e1d << std::endl; // 2.71828182845904509079559829842764884

  float128 e1i = exp(1); // Caution int promoted to double so only 17 decimal digits precision!
  std::cout << e1i << std::endl; // 2.71828182845904509079559829842764884

  float f1 = 1.F;
  float128 e1f = exp(f1); // Caution float so only 6 decimal digits precision out of 36!
  std::cout << e1f << std::endl; // 2.71828174591064453125000000000000000

  // In all these cases you get what you asked for and not what you expected or wanted.

  // Casting is essential if you start with a lower precision type.

  float128 e1q = exp(static_cast<float128>(f1)); // Full 36 decimal digits precision!
  std::cout << e1q << std::endl; // 2.71828182845904523536028747135266231

  float128 e1qc = exp((float128)f1); // Full 36 decimal digits precision!
  std::cout << e1qc << std::endl; // 2.71828182845904523536028747135266231

  float128 e1qcc = exp(float128(f1)); // Full 36 decimal digits precision!
  std::cout << e1qcc << std::endl; // 2.71828182845904523536028747135266231

  //float128 e1q = exp<float128>(1.); // Compile fails.
  // std::cout << e1q << std::endl; //

// http://en.cppreference.com/w/cpp/language/typeid
// The name()is implementation-dependent mangled, and may not be able to be output.
// The example showing output using one of the implementations where type_info::name prints full type names;
// filter through c++filt -t if using gcc or similar.

//[float128_type_info
const std::type_info& tifu128 = typeid(__float128); // OK.
std::cout << "  tifu128.name() = " << tifu128.name() << std::endl;
std::cout << "  typeid(__float128).name() = " << typeid(__float128).name() << std::endl; 

const std::type_info& tif128 = typeid(float128); // OK.
std::cout << tif128.name() << std::endl; // OK.
std::cout << typeid(float128).name() << std::endl; // OK.

const std::type_info& tpi = typeid(pi1); // OK using GCC 6.1.1.
// (from GCC 5 according to http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43622)
std::cout << tpi.name() << std::endl; // OK, Output implementation-dependent mangled name:

// N5boost14multiprecision6numberINS0_8backends16float128_backendELNS0_26expression_template_optionE0EEE

//] [/float128_type_info]

  }
  catch (std::exception ex)
  { // Display details about why any exceptions are thrown.
    std::cout << "Thrown exception " << ex.what() << std::endl;
  }
} // int main()

BOOST Liscense

수학 문제 쉽게 풀기 (사칙연산, 방정식 풀이, 수열과 급수, 극한, 미적분, ...)

Scripter — Tue, 4 Feb 2025 15:55:09 +0900

아래의 링크를 따라가서 알고 싶은 수학식만 적어주면 풀이과정과 답을 알려줍니다.

대수, 기하, 그래프, 곡선, 극한, 유한급수와, 무한급수, 미분과 적분, 해석, 위상, 확룰,

실함수와, 복소함수, 멱급수(power series), 확룰(probability)과 측도(measure), ... 뭐든지 다...

integral of e^xcos (x)

Free Online indefinite integral calculator - solve indefinite integrals with all the steps. Type in any integral to get the solution, steps and graph

www.symbolab.com

카라츄바 곱셈(Karatsuba multiplication) 에 대한 어떤 생각

Scripter — Sun, 24 Dec 2023 12:12:09 +0900

정수의 곱셈을 빨리하기 위한 방법 중의 하나로

기수법으로 표현된 정수를 여러 조각으로 분할하여

덧셈이나 뺄셈 회수는 몇회 증가하는 대신, 곱셈 횟수를 몇회 감소하는

방법입니다. 곱셈이 덧셈이나 뺄셈 보다는 시간이 많이 걸린다는

전제 하에 카라츄바 곱셈(Karatsuba multiplication)을 적용하면

시간복잡도 O(N**2) 의 계산 과정을 을 약 시간복잡도 O(N*&1.5)의 계산 과정으로

줄일 수 있습니다. (여기서 N은 기수법으로 표현된 정수의 분할 개수입니다.)

예를 들어 두 자리 십진법 수 23과 45의 곱셈 23*45을 생각해 봅니다.

(이 경우 N = 2 입니다.)

                  2  3
          x )     4  5
            -----------
                  1  5
               1  0
               1  2
               8
            -----------
            1  0  3  5

위의 곱셈표에서 보듯이,

곱셈은 3*5 = 15, 2*5 = 10, 3*4 = 12, 2*4 = 8 로 모두 4회입니다.

덧셈은 15 + 10 + 12 + 8 로 모두 3회입니다.

그러므로. 곱셈 회수 + 덧셈 회수 = 4(회) + 3(회) = 7(회) 입니다.

덧셈이나 뺄셈을 한 후에 곱셈을 할 때는 분배법칙(혹은 배분법칙)

(a + b)*(c + d) = a*c + b*d + a*d + b*c = (a*c + b*d) + (a*d + b*c)

이 성립하므로 a 에는 2를, b 에는 3을, c에는 4를, d에는 5를 각각 대입하면

(2 + 3)*(4 + 5) = 2*4 + 3*5 + 2*5 + 3*4 = (2*4 + 3*5) + (2*5 + 3*4)

앞에서 했던 계산 중에 2*5 = 10, 3*4 = 12 은 곱셈이 2회인데,

이 계산을 (2 + 3)*(4 + 5) = (2*4 + 3*5) + (2*5 + 3*4)

즉, 2*5 + 3*4 = (2 + 3)*(4 + 5) - (2*4 + 3*5) 임을 이용하면 곱셈을 1회 줄일 수 있습니다. (덧셈과 뺄셈 회수는 조금 불어닙니다.)

왜냐 하면 2*4 = 8 (10의 자리수 곱셈)과 3*5 = 15 (1의 자리수 곱셈)은 미리 했으므로

(2 + 3)*(4 + 5) 만 계산하고 여기에 미리 계산된 (2*5 + 3*4) 을 뺄셈하면 2*5 + 3*4 을

구 할 수 있습니다.

(2 + 3)*(4 + 5) - (2*4 + 3*5) = 5*9 - (8 + 15) = 45 - 23 = 22

이 계산에는 덧셈 1회, 뺄셈 1회, 곱셈 1회입니다.

                  2  3
          x )     4  5
            -----------
               8  1  5
               2  2          = (2 + 3)*(4 + 5) - (8 + 15) = 45 - 23 = 22
            -----------
            1  0  3  5

위의 곱셈표에서 보듯이,

곱셈은 2*4 = 8, 3*5 = 15, (2 + 3)*(4 + 5) = 45 로 모두 3회입니다.

덧셈은 2 + 3 = 5, 4 + 5 = 9, 8 + 15 = 23 으로 모두 3회입니다.

뺄셈은 45 - (8 + 15) 로 1회,

그리고 815 + 220 에 덧셈 1회 입니다.

그러므로 덧셈과 뺄셈은 총 5회, 곱셈은 3회가 됩니다.

그러므로. 곱셈 회수 + 덧셈과 뺄셈 회수 = 3(회) + 5(회) = 8(회) 입니다.

위의 예에서는 두 자리 십진법 수의 곱셈을 보여주었는데,

이 카라츄바 곱셈 방법은 N자리 r진법 수의 곱셈에도 적용할 수 있습니다.

예를 들어, 4자리 16진법수 곱셈 0xCAFE * 0xABBA 에도 적용할 수 있습니다.

                  C  A  F  E
          x )     A  B  B  A
            ----------------

무료로 싑게 쓰는 Small BASIC을 소개합니다.

Scripter — Thu, 21 Dec 2023 11:11:46 +0900

Small BASIC은 Microsoft에서 제작 배포하는 BASIC 언어 인터프리터로서

편집기가 내장되어 있으며, 그래픽 기능도 있으며, Dot NET 4.5 환경에서 동작합니다.

Small BASIC 홈페이지에서 다운로드하여 설치할 수 있으며, 풍부한 튜토리얼도 있습니다.

Small BASIC을 설치하고, 처음 실행한 화면입니다.

다음의 딱 한줄 을 편집기에 쓰고

TextWindow.WriteLine("Hello World!")

파일 저장하고(파일 확장자가 sb로 저장됨), 실행 버튼 누르면

Hello World! 가 출력된 컨솔창이 뜹니다.

아래의 몇 줄을 입력하고

Turtle.Show()
For i = 1 To 45
  Turtle.Turn(8)
  Turtle.Move(10)
EndFor

저장 버튼 누르고, 실행 버튼 누르면 아래 처럼 그래픽이 그려집니다.

2차방정식(quadratic equation)의 근의 공식

Scripter — Fri, 15 Dec 2023 19:48:34 +0900

2차방정식 $$ ax^2 + bx + c = 0 $$

(단, $a != 0$)의 근을 구하는 공식

$$ x = \dfrac{-b \pm \sqrt{b^2 - 4ac}}{2a} $$

황금율(golden ratio)을 구하는 2차방정식 $$ x^2 - x - 1 = 0 $$

의 두 근은

$$ x = \dfrac{1 \pm \sqrt{5}}{2} $$

이고 이 중에 큰 근 $$ x = \dfrac{1 + \sqrt{5}}{2} = 1.618033988749895... $$

이 황금율이다.

네가보나치(Negabonacci) 란

Scripter — Fri, 15 Dec 2023 19:37:46 +0900

피보나치 수열이 0 이상의 정수 n에 대하여

선형점화공식(linear recurency): f(n) = f(n - 1) + f(n - 2) 과

과 초기조건(initial condition): f(0) = 0, f(1) = 1

로 정의된 수열인데 이를 음의 정수 n에 대하여도 위의 점화공식을

f(n) = f(n + 2) - f(n + 1) (∀ n = -1, -2, -3, -4, -5, ...)

로 고쳐 축차 적용하여 얻어지는 수열

f(-1), f(-2), f(-3), f(-4), f(-5), ....

을 네가보나치 수열(negabonacci sequence)이라고 한다.

즉,

f(-1) = f(1) - f(0) = 1 - 0 = 1

f(-2) = f(0) - f(-1) = 0 - 1 = -1

f(-3) = f(-1) - f(-2) = 1 - (-1) = 2

f(-4) = f(-2) - f(-3) = -1 - 2 = -3

f(-5) = f(-3) - f(-4) = 2 - (-3) = 5

f(-6) = f(-4) - f(-5) = -3 - 5 = -8

..............................................

피보나치 수(Fibonacci number)이란?

Scripter — Fri, 15 Dec 2023 18:29:43 +0900

피보나치 수열는 피보나치가 토끼의 성장과 번식을 관찰하다가 발견한 수열이라고 합니다.

피보나치 수(Fibonacci number)의 정의는 간단합니다.

0과 1로 시작해서 덧셈을 계속 이어가면 얻어지는 수들입니다.

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ......

초항을 제 0항으로 하고 제 0항, 제 1항, 제 2항, ...... 순으로 나열하면

F(0), F(1), F(2), F(3), F(4), F(5), F(6), F(7), F(8), F(9), F(10), ......

이 되고, 번호를 괄호 속에 넣지 않고 우측 첨자로 붙여 나열하면,

F₀, F₁, F₂, F₃, F₄, F₅, F₆, F₇, F₈, F₉, F₁₀, ......

이 됩니다. 즉,

F₀ = F(0) = 0

F₁ = F(1) = 1

F₂ = F(2) = 1

F₃ = F(3) = 2

F₄ = F(4) = 3

F₅ = F(5) = 5

F₆ = F(6) = 8

F₇ = F(7) = 13

F₈ = F(8) = 21

F₉ = F(9) = 34

F₁₀ = F(10) = 55

........................

피보나치 수들을 점화공식(recurrence formula)으로 정의하면

F(n) = F(n - 1) + F(n - 2) ∀ n = 2, 3, 4, 5, ...

F(0) = 0, F(1) = 1

가 됩니다.

0 + 1 = 1

1 + 1 = 2

1 + 2 = 3

2 + 3 = 5

3 + 5 = 8

5 + 8 = 13

..........

위의 점화공식 F(n) = F(n - 1) + F(n - 2) 은

F(n) - F(n - 1) = F(n - 2)

혹은

F(n) - F(n - 2) = F(n - 1)

으로 사용되어지기도 합니다.

다시 생각해 보는 Java 의 Native Number

Scripter — Sun, 22 Oct 2023 13:43:54 +0900

Java 에는 부호 없는 native 정수 타입이 없다.

Java 8에 와서야 부호 없는 정수를 처리하기 위한 메서드 몇 개가 추가되었다.

예를 들어, String을 native 타입 number로 변환하는 스태틱 메서드

Long.parseUnsignedLong(String), Integer.parseUnsignedint(String),

Short.parseUnsignedShort(String), Byte.parseUnsignedByte(String),

들과 역으로 native 타입 number를 String으로 변환하는 스태틱 메서드

Long.toUnsignedString(long), Integer.toUnsignedString(int)

가 있는데 이들은 타입 캐스팅할 댸 주의해야 할 부분이 있다.

아래의 Java 소스는 overflow 와 관련하여 심각한 문제가 발생할 수

있음을 보여 준다.

//  Filename: About_Java_Native_Number.java
//
//       Re-consider Java's native numbers (int or long or double) near to theirs maximal valuea
//
//
//  Compile: javac -d . About_Java_Native_Number.java
//  Execute: java About_Java_Native_Number
//
//
// Date: 2023.10.22


public class About_Java_Native_Number
{

    public static void main(String[] args)
    { 
        System.out.printf("What is pow(2, 30) = 2**30 (using Python's integer power operator expression)\n");
        System.out.printf("                   = 1 << 30 (using intege's shift opertor expression)\n");
        System.out.printf("                   = 2^30 (in LaTeX' math expression)\n");
        System.out.printf("\n");

        System.out.printf("Math.pow(2, 30) == %s\n", Math.pow(2, 30));
        System.out.printf("Math.pow(2, 30) == %e\n", Math.pow(2, 30));
        System.out.printf("Math.pow(2, 30) == %.9e\n", Math.pow(2, 30));
        System.out.printf("Math.pow(2, 30) == %g\n", Math.pow(2, 30));
        System.out.printf("Math.pow(2, 30) == %.0g\n", Math.pow(2, 30));
        System.out.printf("Math.pow(2, 30) == %.9g\n", Math.pow(2, 30));
        System.out.printf("Math.pow(2, 30) == %f\n", Math.pow(2, 30));
        System.out.printf("Math.pow(2, 30) == %.0f\n", Math.pow(2, 30));
        System.out.printf("Math.pow(2, 30) == %a\n", Math.pow(2, 30));
        System.out.printf("\n");

        System.out.printf("1 << 30 = %d\n", 1 << 30);
        System.out.printf("(1 << 30) + (1 << 30) = %d\n", (1 << 30) + (1 << 30) );
        System.out.printf("(1 << 30)*2 = %d\n", (1 << 30)*2);
        System.out.printf("1 << (1 << 30) << 1 = %d\n", (1 << 30) << 1 );
        System.out.printf("0x7FFFFFFF = %d\n", 0x7FFFFFFF);
        System.out.printf("0x7FFFFFFF + 1 = %d\n", 0x7FFFFFFF + 1);
        System.out.printf("0x7FFFFFFF + 2 = %d\n", 0x7FFFFFFF + 2);
        System.out.printf("0x7FFFFFFF + 2 = %d\n", 0x7FFFFFFF + 2);
        System.out.printf("0x7FFFFFFF + 1 - 1 = %d\n", 0x7FFFFFFF + 1 - 1);
        System.out.printf("0x7FFFFFFF + 2 - 2 = %d\n", 0x7FFFFFFF + 2 - 2);
        System.out.printf("0x7FFFFFFF + 3 - 3 = %d\n", 0x7FFFFFFF + 3 - 3);
        System.out.printf("\n");

        System.out.printf("Is it true that (0x7FFFFFFF + 1) - 1 = (%d + 1) - 1 = %d - 1 = %d ?\n", 0x7FFFFFFF, 0x7FFFFFFF + 1, (0x7FFFFFFF + 1) - 1);
        System.out.printf("Is it true that (0x7FFFFFFF + 2) - 2 = (%d + 2) - 2 = %d - 2 = %d ?\n", 0x7FFFFFFF, 0x7FFFFFFF + 2, (0x7FFFFFFF + 1) - 2);
        System.out.printf("Is it true that (0x7FFFFFFF + 3) - 3 = (%d + 3) - 3 = %d - 3 = %d ?\n", 0x7FFFFFFF, 0x7FFFFFFF + 3, (0x7FFFFFFF + 1) - 3);
        System.out.printf("\n");

        System.out.printf("It is true that 1 << 30 = %d\n", 1 << 30);
        System.out.printf("But, is it true that (1 << 30)*2/2 = (%d)*2/2 = %d/2 = %d ?\n", 1 << 30, (1 << 30)*2,  (1 << 30)*2/2);
        System.out.printf("And, is it true that (1 << 30)*2/4 = (%d)*2/4 = %d/4 = %d ?\n", 1 << 30, (1 << 30)*2,  (1 << 30)*2/4);
        System.out.printf("And, is it true that (1 << 30)*2/8 = (%d)*2/8 = %d/8 = %d ?\n", 1 << 30, (1 << 30)*2,  (1 << 30)*2/8);
        System.out.printf("\n");

        System.out.printf("Also, is it true that (1 << 30)*4/2 = (%d)*4/2 = %d/2 = %d ?\n", 1 << 30, (1 << 30)*4,  (1 << 30)*4/2);
        System.out.printf("Also, is it true that ((1 << 30)*4 + 1234567)/2 = ((%d)*4 + 1234567)/2 = (%d + 1234567)/2 = %d ?\n", 1 << 30, (1 << 30)*4,  ((1 << 30)*4 + 1234567)/2);
        System.out.printf("Then, is it true that (Math.pow(2, 30)*4 + 1234567)/2 = ((%.0f)*4 + 1234567)/2 = (%.0f + 1234567)/2 = %.0f ?\n", Math.pow(2, 30), Math.pow(2, 30)*4,  (Math.pow(2, 30)*4 + 1234567)/2);


        System.out.printf("In is known that Math.pow(2, 30) == (1 << 30) ? %s\n", Math.pow(2, 30) == (1 << 30));
        System.out.printf("\n");

        System.out.printf("Long.toUnsignedString((byte)0xFFL) = %s\n", Long.toUnsignedString((byte)0xFFL));
        System.out.printf("Long.toUnsignedString(0xFFL) = %s\n", Long.toUnsignedString(0xFFL));
        System.out.printf("Integer.toUnsignedString((byte)0xFFL) = %s\n", Integer.toUnsignedString((byte)0xFFL));
        System.out.printf("Integer.toUnsignedString(0xFF) = %s\n", Integer.toUnsignedString(0xFF));
        System.out.printf("Integer.toUnsignedString(0xFFFFFFFFFF) = %s\n", Integer.toUnsignedString(0xFFFFFFFF));
        System.out.printf("Long.toUnsignedString(0xFFFFFFFFFF) = %s\n", Long.toUnsignedString(0xFFFFFFFF));
        System.out.printf("Long.toUnsignedString(0x100000000L) = %s\n", Long.toUnsignedString(0x100000000L));
        System.out.printf("Long.toUnsignedString(0xFFFFFFFFFFFFFFFFL) = %s\n", Long.toUnsignedString(0xFFFFFFFFFFFFFFFFL));
        System.out.printf("Long.toUnsignedString(0x8000000000000000L) = %s\n", Long.toUnsignedString(0x8000000000000000L));
        System.out.printf("Long.toString(0xFFFFFFFFFFFFFFFFL) = %s\n", Long.toString(0xFFFFFFFFFFFFFFFFL));
        System.out.printf("Long.toString(0x8000000000000000L) = %s\n", Long.toString(0x8000000000000000L));
        System.out.printf("\n");

    }
}

/*
---------
 Output:
---------

What is pow(2, 30) = 2**30 (using Python's integer power operator expression)
                   = 1 << 30 (using intege's shift opertor expression)
                   = 2^30 (in LaTeX' math expression)

Math.pow(2, 30) == 1.073741824E9
Math.pow(2, 30) == 1.073742e+09
Math.pow(2, 30) == 1.073741824e+09
Math.pow(2, 30) == 1.07374e+09
Math.pow(2, 30) == 1e+09
Math.pow(2, 30) == 1.07374182e+09
Math.pow(2, 30) == 1073741824.000000
Math.pow(2, 30) == 1073741824
Math.pow(2, 30) == 0x1.0p30

1 << 30 = 1073741824
(1 << 30) + (1 << 30) = -2147483648
(1 << 30)*2 = -2147483648
1 << (1 << 30) << 1 = -2147483648
0x7FFFFFFF = 2147483647
0x7FFFFFFF + 1 = -2147483648
0x7FFFFFFF + 2 = -2147483647
0x7FFFFFFF + 2 = -2147483647
0x7FFFFFFF + 1 - 1 = 2147483647
0x7FFFFFFF + 2 - 2 = 2147483647
0x7FFFFFFF + 3 - 3 = 2147483647

Is it true that (0x7FFFFFFF + 1) - 1 = (2147483647 + 1) - 1 = -2147483648 - 1 = 2147483647 ?
Is it true that (0x7FFFFFFF + 2) - 2 = (2147483647 + 2) - 2 = -2147483647 - 2 = 2147483646 ?
Is it true that (0x7FFFFFFF + 3) - 3 = (2147483647 + 3) - 3 = -2147483646 - 3 = 2147483645 ?

It is true that 1 << 30 = 1073741824
But, is it true that (1 << 30)*2/2 = (1073741824)*2/2 = -2147483648/2 = -1073741824 ?
And, is it true that (1 << 30)*2/4 = (1073741824)*2/4 = -2147483648/4 = -536870912 ?
And, is it true that (1 << 30)*2/8 = (1073741824)*2/8 = -2147483648/8 = -268435456 ?

Also, is it true that (1 << 30)*4/2 = (1073741824)*4/2 = 0/2 = 0 ?
Also, is it true that ((1 << 30)*4 + 1234567)/2 = ((1073741824)*4 + 1234567)/2 = (0 + 1234567)/2 = 617283 ?
Then, is it true that (Math.pow(2, 30)*4 + 1234567)/2 = ((1073741824)*4 + 1234567)/2 = (4294967296 + 1234567)/2 = 2148100932 ?
In is known that Math.pow(2, 30) == (1 << 30) ? true

Long.toUnsignedString((byte)0xFFL) = 18446744073709551615
Long.toUnsignedString(0xFFL) = 255
Integer.toUnsignedString((byte)0xFFL) = 4294967295
Integer.toUnsignedString(0xFF) = 255
Integer.toUnsignedString(0xFFFFFFFFFF) = 4294967295
Long.toUnsignedString(0xFFFFFFFFFF) = 18446744073709551615
Long.toUnsignedString(0x100000000L) = 4294967296
Long.toUnsignedString(0xFFFFFFFFFFFFFFFFL) = 18446744073709551615
Long.toUnsignedString(0x8000000000000000L) = 9223372036854775808
Long.toString(0xFFFFFFFFFFFFFFFFL) = -1
Long.toString(0x8000000000000000L) = -9223372036854775808
*/

C++ 언어에서 큰 부동소수점수(native double) 의 정확도

Scripter — Sun, 19 Mar 2023 16:45:26 +0900

정수부의 자리수가 조금 큰 부동소수점수(64비트 double 포맷의 수)를 십진수 표현으로 출력해 보았습니다.

십진수로 표현하면 유효자리수 개수가 약 14~15개 정도인데,

Java 언어와 C# 언어에서는 유효수자를 적당한 개수(17개나 15개)로 자르고

그 뒤를 모두 0으로 출력하였지만,

C++ 언어에서는 유효수자 아래 부분을 자르지 않고 모두 출력합니다.

Pyhon, Ruby 언어에서도 C/C++ 언어 처럼 유효수자 아래 부분을 0으로 채우지 않습니다.

물론 Java, C#, Python, C, C++ 어느 프로그램 언어든

십진수로 표현할 때 자르는 방법이나 유효수자 아래 부분을 채우는 방법은 다르지만,

덧셈, 뺄셈, 곱셈, 나누셈, 기타 등등에서 유효수자 아래부분의 처리 결과는 대동소이합니다.

C++ 언어에서 긴 자리 정수를 처리하기 위해

gmplib 를 Visual C/C++ 용으로 개조한 mpir 라이브러리를 사용하였습니다.

// Filename: Test_Of_Native_Double_CPP_01.cpp
//
//
// Compile: cl /utf-8 /EHsc /I. Test_Of_Native_Double_CPP_01.cpp mpir.lib mpirxx.lib
// Execute: Test_Of_Native_Double_CPP_01
// Output:
//                            pow(2, 128) = 340282366920938463463374607431768211456.000000
//                            pow(2, 128) = 340282366920938463463374607431768211456
//     After mpz_pow(r, 2, 128), we get r = 340282366920938463463374607431768211456
//     Let b = 18446744073709551616 = 0x10000000000000000
//     Then we get b * b = 340282366920938463463374607431768211456 = 0x100000000000000000000000000000000
//
//
//  ------------------------------------------------------
//  출처: https://scripting.tistory.com/
//  ------------------------------------------------------


#include <cstdio>
#include <cmath>

#include <mpir.h>
#include <mpirxx.h>

#include <iostream>


using namespace std;

void test_01() 
{
      double y = pow(2, 128);
      printf("                       pow(2, 128) = %f\n", y);
      printf("                       pow(2, 128) = %.f\n", y);
         
    
    mpz_t r, a;

    mpz_init (r);
    mpz_init_set_str(a, "2", 0);

    mpz_pow_ui(r, a, 128);

    gmp_printf("After mpz_pow(r, %Zd, 128), we get r = %Zd\n", a, r);


    mpz_clear(r);
    mpz_clear(a);
    
    mpz_class b, c;


    b = "0x10000000000000000";
    c = b * b;

    cout << "Let b = " << b << " = " << hex << showbase << b << dec << noshowbase << endl;
    cout << "Then we get b * b = " << c << " = " << hex << showbase << c << dec << noshowbase << endl;

                  
}
    
int main(int argc, const char *argv[])
{
    test_01();
    printf("\n");
}