pystacker 1.0.3__py3.10.egg

EGG-INFO/PKG-INFO

@@ -0,0 +1,446 @@
+Metadata-Version: 2.1
+Name: pystacker
+Version: 1.0.3
+Summary: Stacker: RPN Calculator in Python
+Home-page: https://github.com/remokasu/stacker
+Author: remokasu
+License: MIT License
+        
+        Copyright (c) 2023 Remokasu
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Keywords: reverse-polish-calculator rpn terminal-app
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Stacker: RPN Calculator in Python
+~~~
+  _____  _                 _
+ / ____|| |               | |
+| (___  | |_   __ _   ___ | | __  ___  _ __
+ \___ \ | __| / _` | / __|| |/ / / _ \| '__|
+ ____) || |_ | (_| || (__ |   < |  __/| |
+|_____/  \__| \__,_| \___||_|\_\ \___||_|
+
+~~~
+
+
+# Download & Install
+
+If you don't have Python 3 installed, please install it beforehand.
+Here are the installation instructions for `stacker`:
+
+1. Download
+~~~ bash
+> git clone git@github.com:remokasu/stacker.git
+~~~
+
+2. Install dependencies
+~~~
+pip install setuptools
+~~~
+
+* For Windows users only
+~~~ bash
+> pip install pyreadline
+~~~
+
+3. Run the program without installation
+~~~ bash
+> cd stacker/stacker
+> python stacker.py
+~~~
+
+4. (Or) Install and run the program
+~~~ bash
+cd stacker
+> python setup.py install
+> stacker
+~~~
+
+* When you're done playing with it, uninstall
+~~~ bash
+> pip uninstall stacker
+~~~
+
+
+| Operator | Description                                           | Example                    | Result                   |
+|----------|-------------------------------------------------------|----------------------------|--------------------------|
+| +        | Add                                                   | `3 5 +`                    | 8                        |
+| -        | Subtract                                              | `10 3 -`                   | 7                        |
+| *        | Multiply                                              | `4 6 *`                    | 24                       |
+| /        | Divide                                                | `12 4 /`                   | 3                        |
+| //       | Integer divide                                        | `7 2 //`                   | 3                        |
+| %        | Modulus                                               | `9 2 %`                    | 1                        |
+| ^        | Power                                                 | `3 2 ^`                    | 9                        |
+| neg      | Negate                                                | `5 neg`                    | -5                       |
+| abs      | Absolute value                                        | `-3 abs`                   | 3                        |
+| exp      | Exponential                                           | `3 exp`                    | math.exp(3)              |
+| log      | Natural logarithm                                     | `2 log`                    | math.log(2)              |
+| log10    | Common logarithm (base 10)                            | `4 log10`                  | math.log10(4)            |
+| log2     | Logarithm base 2                                      | `4 log2`                   | math.log2(4)             |
+| sin      | Sine                                                  | `30 sin`                   | math.sin(30)             |
+| cos      | Cosine                                                | `45 cos`                   | math.cos(45)             |
+| tan      | Tangent                                               | `60 tan`                   | math.tan(60)             |
+| asin     | Arcsine                                               | `0.5 asin`                 | math.asin(0.5)           |
+| acos     | Arccosine                                             | `0.5 acos`                 | math.acos(0.5)           |
+| atan     | Arctangent                                            | `1 atan`                   | math.atan(1)             |
+| sinh     | Hyperbolic sine                                       | `1 sinh`                   | math.sinh(1)             |
+| cosh     | Hyperbolic cosine                                     | `1 cosh`                   | math.cosh(1)             |
+| tanh     | Hyperbolic tangent                                    | `1 tanh`                   | math.tanh(1)             |
+| asinh    | Inverse hyperbolic sine                               | `1 asinh`                  | math.asinh(1)            |
+| acosh    | Inverse hyperbolic cosine                             | `2 acosh`                  | math.acosh(2)            |
+| atanh    | Inverse hyperbolic tangent                            | `0.5 atanh`                | math.atanh(0.5)          |
+| sqrt     | Square root                                           | `9 sqrt`                   | math.sqrt(9)             |
+| ceil     | Ceiling                                               | `3.2 ceil`                 | math.ceil(3.2)           |
+| floor    | Floor                                                 | `3.8 floor`                | math.floor(3.8)          |
+| round    | Round                                                 | `3.5 round`                | round(3.5)               |
+| float    | Convert to floating-point number                      | `5 float`                  | 5.0                      |
+| int      | Convert to integer                                    | `3.14 int`                 | 3                        |
+| ==       | Equal                                                 | `1 1 ==`                   | True                     |
+| !=       | Not equal                                             | `1 0 !=`                   | True                     |
+| <        | Less than                                             | `1 2 <`                    | True                     |
+| <=       | Less than or equal to                                 | `3 3 <=`                   | True                     |
+| >        | Greater than                                          | `2 1 >`                    | True                     |
+| >=       | Greater than or equal to                              | `3 3 >=`                   | True                     |
+| and      | Logical and                                           | `true false and`           | False                    |
+| or       | Logical or                                            | `true false or`            | True                     |
+| not      | Logical not                                           | `true not`                 | False                    |
+| band     | Bitwise and                                           | `3 2 band`                 | 3 & 2                    |
+| bor      | Bitwise or                                            | `3 2 bor`                  | 3 | 2                    |
+| bxor     | Bitwise xor                                           | `3 2 bxor`                 | 3 ^ 2                    |
+| gcd      | Greatest common divisor                               | `4 2 gcd`                  | math.gcd(4, 2)           |
+| !        | Factorial                                             | `4 !`                      | math.factorial(4)        |
+| radians  | Convert degrees to radians                            | `180 radians`              | math.radians(180)        |
+| roundn   | Round to specified decimal places                     | `3.51 1 roundn`            | round(3.51, 1)           |
+| random   | Generate a random floating-point number between 0 and 1| `random`                   | random.random()          |
+| randint  | Generate a random integer within a specified range    | `1 6 randint`              | random.randint(1, 6)     |
+| uniform  | Generate a random floating-point number within a specified range | `1 2 uniform` | random.uniform(1, 2) |
+| d        | Roll dice (e.g., 3d6)                                 | `3 6 d`                     | sum(random.randint(1, 6) for _ in range(3)) |
+
+
+<hr>
+
+## Custom Functions::
+
+### Example 2: Function to calculate the average of two numbers (average)
+~~~ bash
+stacker:0> x y average => x y + 2 /
+stacker:1> 2 6 average
+[4.0]
+~~~
+
+
+(Note that the function definition syntax is a custom RPN-like syntax, so please don't worry about it)
+
+<br>
+
+<hr>
+
+## You can also enter input like this. In fact, this is the normal way to use it.
+(Example) 3 4 +
+~~~ bash
+stacker:0> 3
+[3.0]
+stacker:1> 4
+[3.0, 4.0]
+stacker:2> +
+[7.0]
+~~~
+
+## clear
+Clear the stack with 'clear'
+~~~
+stacker:0> clear
+[]
+~~~
+
+## exit
+Exit the program with 'exit'
+~~~
+stacker:0> exit
+~~~
+
+## about
+Display Stacker's information with `about` (not particularly meaningful)
+~~~
+stacker:0> about
+~~~
+
+## help
+Display usage instructions with `help`
+~~~
+stacker:0> help
+~~~
+
+
+<br>
+<hr>
+
+# 概要
+
+ある晴れた日、学生Aは数学の試験に挑むため、緊張しながら教室へ向かっていました。しかし、彼はある重要なものを忘れてしまっていたのです。それは、関数電卓でした。
+
+<br>
+
+`学生A（焦りながら）`
+~~~
+先生、電卓を忘れちゃったんですが、お借りできますか？
+~~~
+
+`教授（待ってました！と言いたげな表情で）`
+~~~
+もちろんだ。特別に君にコレを貸してあげよう。
+ヒューレットパッカードの稀代の名機 「hp 50G」！！
+とっくに生産終了してしまって今では新品で買うことなど不可能なシロモノだ。
+Amaz●nではプレミアがついて10倍の値段で取引されている。
+このでっかい画面にはグラフも描画できちゃうぞ！
+さらにこの小さな端子はなななななんとRS-232！シリアル通信だってできちゃう！
+電卓のくせに一体何と通信するんだろうねぇ！？
+まあ、何故かコネクタは公式から発売されることは無かったから実質幻の機能だがな...
+どうだ？凄いだろう？
+~~~
+
+`学生A（顔を輝かせつつ）`
+~~~
+ええっ！なにそれチートアイテムぅ！？（よく分かんないけど凄そう！デカイし！)
+やったあ...これで試験も余裕です！！(泣）
+~~~
+
+`教授（ニヤリと笑いながら）`
+~~~
+ただし、これは逆ポーランド記法の電卓だぞ
+~~~
+
+`学生A（戸惑いつつ）`
+~~~
+逆ポ...？逆ポーランドって何です？よく分かんないけど、なんかカッコいいですね！
+~~~
+
+`教授（クスクス笑い）`
+~~~
+ちょっと普通の電卓とは扱い方が異なるだけだ。
+なに、心配することはないよ。普通の電卓のようなモードにも切り替えられるからね。
+~~~
+
+`学生A（安心しながら）`
+~~~
+なるほど！ありがとうございます！！たすかりましたああ！！
+~~~
+
+`教授（声には出さず）`
+~~~
+（ただし切り替え方は初見では分かり難いだろうねｸｸｸ...）
+~~~
+
+
+<br>
+その試験で学生Aは泣いたという。
+
+このプログラムは、A君のトラウマを追体験することができる。
+
+<br>
+
+<hr>
+
+# ダウンロード & インストール
+
+python3が無ければ事前にインストールしてください。
+以下は`stacker`のインストール方法です。
+
+1. ダウンロード & インストール
+~~~ bash
+> pip install pystacker
+~~~
+
+2. 起動
+~~~
+> stacker
+~~~
+
+* windowsの場合の場合、追加で実行
+~~~ bash
+> pip install pyreadline
+~~~
+
+* 遊び終わったら削除しましょう
+~~~ bash
+> pip uninstall pystacker
+~~~
+
+# 使い方
+
+| 演算子   | 説明                                                  | 使い方                      | 結果                       |
+|--------|-----------------------------------------------------|--------------------------|--------------------------|
+| +      | 加算                                                  | `3 5 +`                    | 8                        |
+| -      | 減算                                                  | `10 3 -`                   | 7                        |
+| *      | 乗算                                                  | `4 6 *`                    | 24                       |
+| /      | 除算                                                  | `12 4 /`                   | 3                        |
+| //     | 整数除算                                              | `7 2 //`                   | 3                        |
+| %      | 剰余                                                  | `9 2 %`                    | 1                        |
+| ^      | 累乗                                                  | `3 2 ^`                    | 9                        |
+| neg    | 符号反転                                              | `5 neg`                    | -5                       |
+| abs    | 絶対値                                                | `-3 abs`                   | 3                        |
+| exp    | 指数関数                                              | `3 exp`                    | math.exp(3)              |
+| log    | 自然対数                                              | `2 log`                    | math.log(2)              |
+| log10  | 常用対数 (底10)                                       | `4 log10`                  | math.log10(4)            |
+| log2   | 底2の対数                                             | `4 log2`                   | math.log2(4)             |
+| sin    | 正弦                                                  | `30 sin`                   | math.sin(30)             |
+| cos    | 余弦                                                  | `45 cos`                   | math.cos(45)             |
+| tan    | 正接                                                  | `60 tan`                   | math.tan(60)             |
+| asin   | 逆正弦                                                | `0.5 asin`                 | math.asin(0.5)           |
+| acos   | 逆余弦                                                | `0.5 acos`                 | math.acos(0.5)           |
+| atan   | 逆正接                                                | `1 atan`                   | math.atan(1)             |
+| sinh   | 双曲線正弦                                            | `1 sinh`                   | math.sinh(1)             |
+| cosh   | 双曲線余弦                                            | `1 cosh`                   | math.cosh(1)             |
+| tanh   | 双曲線正接                                            | `1 tanh`                   | math.tanh(1)             |
+| asinh  | 逆双曲線正弦                                          | `1 asinh`                  | math.asinh(1)            |
+| acosh  | 逆双曲線余弦                                          | `2 acosh`                  | math.acosh(2)            |
+| atanh  | 逆双曲線正接                                          | `0.5 atanh`                | math.atanh(0.5)          |
+| sqrt   | 平方根                                                | `9 sqrt`                   | math.sqrt(9)             |
+| ceil   | 切り上げ                                              | `3.2 ceil`                 | math.ceil(3.2)           |
+| floor  | 切り捨て                                              | 3.8 floor                  | math.floor(3.8)          |
+| round  | 四捨五入                                              | 3.5 round                  | round(3.5)               |
+| float  | 浮動小数点数に変換                                    | 5 float                    | 5.0                      |
+| int    | 整数に変換                                            | 3.14 int                   | 3                        |
+| ==     | 等しい                                                | 1 1 ==                     | True                     |
+| !=     | 等しくない                                            | 1 0 !=                     | True                     |
+| <      | より小さい                                            | 1 2 <                      | True                     |
+| <=     | 以下                                                  | 3 3 <=                     | True                     |
+| >      | より大きい                                            | 2 1 >                      | True                     |
+| >=     | 以上                                                  | 3 3 >=                     | True                     |
+| and    | 論理積                                                | true false and             | False                    |
+| or     | 論理和                                                | true false or              | True                     |
+| not    | 論理否定                                              | true not                   | False                    |
+| band   | ビットごとの論理積                                    | 3 2 band                   | 3 & 2                    |
+| bor    | ビットごとの論理和                                    | 3 2 bor                    | 3 | 2                    |
+| bxor   | ビットごとの排他的論理和                              | 3 2 bxor                   | 3 ^ 2                    |
+| gcd    | 最大公約数                                            | 4 2 gcd                    | math.gcd(4, 2)           |
+| !      | 階乗                                                  | 4 !                        | math.factorial(4)        |
+| radians| 度数法から弧度法へ変換                                | 180 radians                | math.radians(180)        |
+| roundn | 指定した小数点以下の桁数で四捨五入                    | 3.51 1 roundn              | round(3.51, 1)           |
+| random | 0と1の間の乱数を生成                                  | random                     | random.random()          |
+| randint| 指定した範囲内の整数乱数を生成                        | 1 6 randint                | random.randint(1, 6)     |
+| uniform| 指定した範囲内の浮動小数点数乱数を生成                | 1 2 uniform                | random.uniform(1, 2)     |
+| d      | サイコロを振る (例：3d6)                              | 3 6 d                      | sum(random.randint(1, 6) for _ in range(3)) |
+
+
+<br>
+<hr>
+
+## 自作関数:
+
+### 例 1: 二つの数の平均を計算する関数 (average)
+~~~ bash
+stacker:0> x y average => x y + 2 /
+stacker:1> 2 6 average
+[4.0]
+~~~
+
+
+(関数定義の構文はRPN構文っぽい独自定義の構文なので突っ込まないでくれ)
+
+<br>
+
+<hr>
+
+## こんな入力も出来るよ。というかこっちが普通の使い方
+(例) 3 4 +
+~~~ bash
+stacker:0> 3
+[3.0]
+stacker:1> 4
+[3.0, 4.0]
+stacker:2> +
+[7.0]
+~~~
+
+## clear
+`clear` でスタックを初期化
+~~~
+stacker:0> clear
+[]
+~~~
+
+## exit
+`exit` で終了
+~~~
+stacker:0> exit
+~~~
+
+## about
+`about` でStackerの情報を表示(特に意味なし)
+~~~
+stacker:0> about
+~~~
+
+## help
+`help` で使い方を表示
+~~~
+stacker:0> help
+~~~
+
+# おまけ
+
+## eval (逆ポーランドなんてクソ喰らえだ)
+シングルコーテーションで囲った文字列を `eval` で評価できる。
+やはり中置記法こそ正義なのです。
+ところで、なんで君はStackerを使ってるんですか？
+~~~
+stacker:0> '3 + 5' eval
+[8]
+stacker:1> 
+~~~
+
+## exec (Pythonが使いたい)
+シングルコーテーションでかこった範囲は改行しても一連の文字列として認識できる。
+そこにPythonコードをぶっこんで `exec` で実行できる。
+ただし、execはどんな処理でも結果が`None`なので結果はスタックに入らない。
+結果を表示したければptint文を式中に埋め込もう。
+文字列に対して`exec`することでPythonの処理として実行できる。
+この機能、危険な香りがしますね。
+~~~
+stacker:0> '
+stacker:0> def f(x):
+stacker:0>      return x**2
+stacker:0> print(f(4))
+stacker:0> '
+['\ndef f(x):\n\treturn x**2\nprint(f(4))\n']
+stacker:7> exec
+16
+[]
+~~~
+
+・面倒くさいので以後はこうしましょうね。
+~~~
+stacker:10> '
+stacker:10> from subprocess import run
+stacker:10> run("python")
+stacker:10> '
+['\nfrom subprocess import run\nrun("python")\n']
+stacker:11> exec
+Python 3.10.6 (main, Mar 10 2023, 10:55:28) [GCC 11.3.0] on linux
+Type "help", "copyright", "credits" or "license" for more information.
+>>>
+~~~
+
+<br>
+<hr>
+

EGG-INFO/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+setup.py
+pystacker.egg-info/PKG-INFO
+pystacker.egg-info/SOURCES.txt
+pystacker.egg-info/dependency_links.txt
+pystacker.egg-info/entry_points.txt
+pystacker.egg-info/requires.txt
+pystacker.egg-info/top_level.txt
+stacker/__init__.py
+stacker/stacker.py
+stacker/test.py
+stacker/data/about.txt
+stacker/data/help.txt
+stacker/data/top.txt

EGG-INFO/dependency_links.txt

@@ -0,0 +1 @@
+

EGG-INFO/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stacker = stacker.stacker:main

EGG-INFO/not-zip-safe

@@ -0,0 +1 @@
+

EGG-INFO/requires.txt

@@ -0,0 +1 @@
+prompt-toolkit

EGG-INFO/top_level.txt

@@ -0,0 +1 @@
+stacker

stacker/__init__.py

@@ -0,0 +1,7 @@
+import os
+
+# リソースフォルダへのパスを取得する
+resource_path = os.path.join(os.path.dirname(__file__), 'data')
+
+# モジュールにパスを追加する
+__path__.append(resource_path)

stacker/data/about.txt

@@ -0,0 +1,9 @@
+Welcome to Stacker, where we stack things up - but only in the right order! 😉
+This powerful, yet humble, Reverse Polish Notation (RPN) calculator is here to make your life easier.
+We know, it's not every day you encounter a calculator that loves postfix expressions as much as we do. 🤓
+
+With Stacker, you'll experience the joy of crunching numbers without the hassle of parentheses. 🥴
+Our calculator is so dedicated to the cause that it even lets you define your own functions - isn't that fantastic? 🚀
+
+So, go ahead and give Stacker a spin! Just remember, if you ever feel lost, type "help" and we'll be there for you.
+Happy stacking! 🎉

stacker/data/help.txt

@@ -0,0 +1,30 @@
+Enter RPN expression, variable assignment, or function definition.
+Type 'exit' to quit.
+
+Examples:
+  RPN expression: 3 4 +
+  Variable assignment: x = 5
+  Function definition: x y func => x y *
+  Function call: 4 5 func
+
+Supported operators and functions:
+  Arithmetic: +, -, *, /, //, %, ^, neg, abs
+  Comparison: ==, !=, <, <=, >, >=
+  Logical: and, or, not
+  Bitwise: band, bor, bxor
+  Math functions:
+    exp, log, log10, log2, sin, cos, tan, asin, acos, atan,
+    sinh, cosh, tanh, asinh, acosh, atanh, sqrt, cbrt,
+    ceil, floor, round, roundn, random, randint, uniform, d,
+    ncr((nCr)), npr(nPr)
+
+  Type conversion: int2float, float2int
+  Factorial: !
+  GCD: gcd
+
+Usage:
+  Input numbers and operators in RPN notation, separated by spaces.
+  Press Enter to evaluate the expression and display the result.
+  The result will be pushed onto the stack.
+  To use the result in a subsequent calculation, input the next expression.
+  To clear the stack, type 'clear'.

stacker/data/top.txt

@@ -0,0 +1,6 @@
+  _____  _                 _
+ / ____|| |               | |
+| (___  | |_   __ _   ___ | | __  ___  _ __
+ \___ \ | __| / _` | / __|| |/ / / _ \| '__|
+ ____) || |_ | (_| || (__ |   < |  __/| |
+|_____/  \__| \__,_| \___||_|\_\ \___||_|

stacker/stacker.py

@@ -0,0 +1,501 @@
+from __future__ import annotations
+
+import cmath
+import copy
+import math
+import os
+import random
+import re
+import shlex
+from pathlib import Path
+from typing import Optional
+
+import pkg_resources
+from prompt_toolkit import prompt
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.history import FileHistory
+
+history_file = ".stacker_history"
+history_file_path = Path.home() / history_file
+
+
+COLORS = {
+    "black": "\033[30m",
+    "red": "\033[31m",
+    "green": "\033[32m",
+    "yellow": "\033[33m",
+    "blue": "\033[34m",
+    "magenta": "\033[35m",
+    "cyan": "\033[36m",
+    "lightgray": "\033[37m",
+    "default": "\033[39m",
+    "darkgray": "\033[90m",
+    "lightred": "\033[91m",
+    "lightgreen": "\033[92m",
+    "lightyellow": "\033[93m",
+    "lightblue": "\033[94m",
+    "lightmagenta": "\033[95m",
+    "lightcyan": "\033[96m",
+    "white": "\033[97m",
+    "reset": "\033[0m",
+}
+
+
+def colored(text: str, color: Optional[str] = "default", end: str = "\n") -> None:
+    """A context manager for setting and resetting the terminal color.
+    Args:
+        color (str, optional): The desired text color. Defaults to "default".
+    Returns:
+        None
+    """
+    ctext = COLORS[color] + text + COLORS["reset"]
+    return ctext
+
+
+def show_top():
+    # colors = ["red", "green", "yellow", "cyan", "lightred", "lightyellow"]
+    colors = ["red", "green", "yellow", "lightblue", "lightmagenta", "cyan"]
+    with pkg_resources.resource_stream(__name__, "data/top.txt") as f:
+        messages = f.readlines()
+        for i in range(len(messages)):
+            print(colored(messages[i].decode('utf-8'), colors[i]), end="")
+    print("")
+    # with pkg_resources.resource_stream(__name__, "data/top.txt") as f:
+    #     message = f.read().decode('utf-8')
+    # print(message)
+
+
+def show_about():
+    with pkg_resources.resource_stream(__name__, "data/about.txt") as f:
+        message = f.read().decode('utf-8')
+    print(message)
+
+
+def show_help():
+    with pkg_resources.resource_stream(__name__, "data/help.txt") as f:
+        message = f.read().decode('utf-8')
+    print(message)
+
+
+def delete_history():
+    if history_file_path.exists():
+        history_file_path.unlink()
+
+
+def input_to_str_or_int_or_float(input_str: str) -> int | float | str:
+    try:
+        return int(input_str)
+    except ValueError:
+        pass
+    try:
+        return float(input_str)
+    except ValueError:
+        pass
+    try:
+        return complex(input_str)
+    except ValueError:
+        pass
+    return input_str
+
+
+# 入力が実数か虚数かで呼び出すモジュールを切り替える
+def wrap(func, cfunc):
+    def wrapper(x):
+        if isinstance(x, complex):
+            return cfunc(x)
+        return func(x)
+    return wrapper
+
+
+def math_pow(x1, x2):
+    if isinstance(x1, complex) or isinstance(x2, complex):
+        return cmath.exp(x2 * cmath.log(x1))
+    else:
+        return math.pow(x1, x2)
+
+
+def math_log2(x):
+    if isinstance(x, complex):
+        return cmath.log(x) / cmath.log(2)
+    else:
+        return math.log2(x)
+
+
+math_exp = wrap(math.exp, cmath.exp)
+math_log = wrap(math.log, cmath.log)
+math_log10 = wrap(math.log10, cmath.log10)
+math_sin = wrap(math.sin, cmath.sin)
+math_cos = wrap(math.cos, cmath.cos)
+math_tan = wrap(math.tan, cmath.tan)
+math_asin = wrap(math.asin, cmath.asin)
+math_acos = wrap(math.acos, cmath.acos)
+math_atan = wrap(math.atan, cmath.atan)
+math_sinh = wrap(math.sinh, cmath.sinh)
+math_cosh = wrap(math.cosh, cmath.cosh)
+math_tanh = wrap(math.tanh, cmath.tanh)
+math_asinh = wrap(math.asinh, cmath.asinh)
+math_acosh = wrap(math.acosh, cmath.acosh)
+math_atanh = wrap(math.atanh, cmath.atanh)
+math_sqrt = wrap(math.sqrt, cmath.sqrt)
+
+
+class Stacker:
+    def __init__(self):
+        self.stack = []  # スタックを追加
+        self.last_pop = None  # pop コマンド(ユーザー入力)で取り出した値を一時的に格納。演算でpopする場合は対象外
+        self.operator = {
+            "==": (lambda x1, x2: x1 == x2),  # 等しい
+            "!=": (lambda x1, x2: x1 != x2),  # 等しくない
+            "<": (lambda x1, x2: x1 < x2),  # より小さい
+            "<=": (lambda x1, x2: x1 <= x2),  # 以下
+            ">": (lambda x1, x2: x1 > x2),  # より大きい
+            ">=": (lambda x1, x2: x1 >= x2),  # 以上
+            "and": (lambda x1, x2: x1 and x2),  # 論理積
+            "or": (lambda x1, x2: x1 or x2),  # 論理和
+            "not": (lambda x: not x),  # 否定
+            "band": (lambda x1, x2: int(x1) & int(x2)),  # ビット毎の and
+            "bor": (lambda x1, x2: int(x1) | int(x2)),  # ビット毎の or
+            "bxor": (lambda x1, x2: int(x1) ^ int(x2)),  # ビット毎の xor
+            "+": (lambda x1, x2: x1 + x2),  # 加算
+            "-": (lambda x1, x2: x1 - x2),  # 減算
+            "*": (lambda x1, x2: x1 * x2),  # 乗算
+            "/": (lambda x1, x2: x1 / x2),  # 除算
+            "//": (lambda x1, x2: x1 // x2),  # 整数除算
+            "%": (lambda x1, x2: x1 % x2),  # 剰余
+            "^": (lambda x1, x2: math_pow(x1, x2)),  # べき乗
+            "gcd": (lambda x1, x2: math.gcd(int(x1), int(x2))),  # 最大公約数
+            "lcm": (lambda x1, x2: math.lcm(int(x1), int(x2))),  # 最小公倍数
+            "neg": (lambda x: -x),  # 符号反転
+            "abs": (lambda x: abs(x)),  # 絶対値
+            "exp": (lambda x: math_exp(x)),  # 指数関数
+            "log": (lambda x: math_log(x)),  # 自然対数
+            "log10": (lambda x: math_log10(x)),  # 常用対数（底が10）
+            "log2": (lambda x: math_log2(x)),  # 常用対数（底が10）
+            "sin": (lambda x: math_sin(x)),  # 正弦関数
+            "cos": (lambda x: math_cos(x)),  # 余弦関数
+            "tan": (lambda x: math_tan(x)),  # 正接関数
+            "asin": (lambda x: math_asin(x)),  # アークサイン
+            "acos": (lambda x: math_acos(x)),  # アークコサイン
+            "atan": (lambda x: math_atan(x)),  # アークタンジェント
+            "sinh": (lambda x: math_sinh(x)),  # 双曲線正弦
+            "cosh": (lambda x: math_cosh(x)),  # 双曲線余弦
+            "tanh": (lambda x: math_tanh(x)),  # 双曲線正接
+            "asinh": (lambda x: math_asinh(x)),  # 双曲線正弦の逆関数
+            "acosh": (lambda x: math_acosh(x)),  # 双曲線余弦の逆関数
+            "atanh": (lambda x: math_atanh(x)),  # 双曲線正接の逆関数
+            "sqrt": (lambda x: math_sqrt(x)),  # 平方根
+            "radians":  (lambda deg: math.radians(deg)),  # ディグリー(度、Degree)からラジアン(弧度、Radian)に変換
+            "!": (lambda x: math.factorial(int(x))),  # 階乗
+            "cbrt": (lambda x: pow(x, 1/3)),  # 立方根
+            "ncr": (lambda n, k: math.comb(int(n), int(k))),  # 組み合わせ (nCr)
+            "npr": (lambda n, k: math.perm(int(n), int(k))),  # 順列 (nPr)
+            "float": (lambda x: float(x)),  # 整数を浮動小数点数に変換
+            "int": (lambda x: int(x)),  # 浮動小数点数を整数に変換
+            "ceil": (lambda x: math.ceil(x)),    # 小数点以下を切り上げた最小の整数
+            "floor": (lambda x: math.floor(x)),  # 小数点以下を切り捨てた最大の整数
+            "round": (lambda x: round(x)),  # 最も近い整数に四捨五入
+            "roundn": (lambda x1, x2: round(x1, int(x2))),  # 任意の桁数で丸める
+            "random": (lambda: random.random()),  # 0から1までの範囲でランダムな浮動小数点数を生成
+            "randint": (lambda x1, x2: random.randint(int(x1), int(x2))),  # 指定された範囲でランダムな整数を生成
+            "uniform": (lambda x1, x2: random.uniform(x1, x2)),  # 指定された範囲でランダムな浮動小数点数を生成
+            "d": (lambda num_dice, num_faces: sum(random.randint(1, int(num_faces)) for _ in range(int(num_dice)))),  # ダイスロール(例 3d6)
+            "delete": (lambda index: self.stack.pop(index)),  # 指定のindexを削除
+            "pluck": (lambda index: self.stack.pop(index)),  # 指定のindexを削除し、スタックのトップに移動
+            "pick": (lambda index: self.stack.append((self.stack[index]))),  # 指定されたインデックスの要素をスタックのトップにコピー
+            "pop": (lambda: self.stack.pop()),  # pop
+            "exec": (lambda command: exec(command, globals())),  # 指定のPythonコードを実行
+            "eval": (lambda command: eval(command)),  # 指定のPython式を評価
+        }
+        self.variables = {
+            "pi": math.pi,
+            "tau": math.tau,
+            "e": math.e,
+            "true": True,
+            "false": False,
+            "inf": float("inf"),
+            "nan": math.nan,
+        }
+        self.functions = {}
+        self.reserved_word = ["help", "about", "exit", "delete_history"]
+
+    # def get_operators_with_n_args(self, n: int):
+    #     # 任意の引数の数に対応する演算子の一覧を取得
+    #     matching_operators = []
+
+    #     for label, func in self.operator.items():
+    #         if func.__code__.co_argcount == n:
+    #             matching_operators.append(label)
+
+    #     return matching_operators
+
+    def get_n_args_for_operator(self, token):
+        # token(演算子)に必要な引数の数
+        if token in self.operator:
+            return self.operator[token].__code__.co_argcount
+        else:
+            raise KeyError(f"Invalid token {token}")
+
+    def highlight_syntax(self, expression):
+        """
+        Highlights the syntax of the given RPN expression.
+        Returns a colored string of the input expression.
+        """
+        tokens = expression.split()
+        highlighted_tokens = []
+
+        for token in tokens:
+            if token in self.operator:
+                color = "cyan"
+                if token in {"==", "!=", "<", "<=", ">", ">="}:
+                    color = "yellow"
+                elif token in {"and", "or"}:
+                    color = "green"
+                highlighted_tokens.append(colored(token, color))
+            else:
+                try:
+                    float(token)
+                    highlighted_tokens.append(colored(token, "white"))
+                except ValueError:
+                    highlighted_tokens.append(colored(token, "red"))
+
+        return " ".join(highlighted_tokens)
+
+    def clear_stack(self):
+        self.stack = []
+
+    def define_function(self, name, arg_labels, expression):
+        self.validate_name(name)
+        self.functions[name] = (arg_labels, expression)
+
+    def validate_name(self, name):
+        """
+        Validates if a given name is not a reserved word or an operator.
+        Raises a ValueError if the name is invalid.
+        """
+        if name in self.operator or name.lower() in self.reserved_word:
+            raise ValueError(f"Invalid name '{name}', it is a reserved word.")
+        return name
+
+    def assign_variable(self, name, value):
+        """
+        Assigns a value to a variable with the given name.
+        """
+        self.variables[name] = value
+
+    def evaluate_function(self, name, *args):
+        """
+        Evaluates a function with the given name and arguments.
+        Returns the result of the evaluation.
+        """
+        arg_labels, expression = self.functions[name]  # 引数のラベルと式を取得
+        if len(arg_labels) != len(args):
+            raise ValueError(f"Function '{name}' requires {len(arg_labels)} arguments, {len(args)} provided")
+        for label, arg in zip(arg_labels, args):  # 引数の値を割り当てる
+            self.assign_variable(label, arg)
+        result = self.evaluate(expression)
+        return result[-1]  # 評価された関数の結果だけを返す
+
+    def apply_operator(self, token, stack):
+        """
+        Applies an operator to the top elements on the stack.
+        Modifies the stack in-place.
+        """
+        n_args = self.get_n_args_for_operator(token)
+        if n_args is None:
+            raise ValueError(f"Unknown operator '{token}'")
+
+        if len(stack) < n_args:
+            raise ValueError(f"Not enough operands for operator '{token}'")
+
+        args = [stack.pop() for _ in range(n_args)]
+        args.reverse()  # 引数の順序を逆にする
+
+        ans = self.operator[token](*args)
+        if token in {"exec", "delete", "pick"}:  # このコマンド実行時は戻り値NoneをStackしない
+            return
+        elif token == "pop":  # popの場合は戻り値を保存
+            self.last_pop = ans
+        else:
+            stack.append(ans)  # stackは参照渡し
+
+    def evaluate(self, expression, stack=None):
+        """
+        Evaluates a given RPN expression.
+        Returns the result of the evaluation.
+        """
+        if stack is None:
+            stack = []
+
+        # tokens = expression.split()
+        tokens = shlex.split(expression)
+        for token in tokens:
+            # token: (str)
+            if token in self.operator:
+                self.apply_operator(token, stack)
+            elif token == "=>":
+                continue
+            elif token == "last_pop":  # popコマンドでpopした値
+                stack.append(self.last_pop)
+            elif token in self.variables:
+                stack.append(self.variables[token])  # 定数をスタックにプッシュ
+            elif token in self.functions:
+                if len(stack) < len(self.functions[token][0]):
+                    raise ValueError(f"Not enough arguments for function '{token}'")
+                args = [stack.pop() for _ in range(len(self.functions[token][0]))][::-1]
+                stack.append(self.evaluate_function(token, *args))
+            else:
+                try:
+                    # stack.append(float(token))
+                    stack.append(input_to_str_or_int_or_float(token))
+                except ValueError:
+                    raise ValueError(f"Invalid token '{token}'")
+
+        return stack
+
+    def process_function_definition(self, expression):
+        tokens = expression.split()
+        name = tokens[tokens.index("=>") - 1]
+        self.validate_name(name)
+        arg_labels = tokens[:tokens.index("=>") - 1]  # 引数のラベルを取得
+        function_expression = " ".join(tokens[tokens.index("=>") + 1:])
+        if name in self.operator:
+            raise ValueError(f"Invalid function name '{name}'")
+        self.define_function(name, arg_labels, function_expression)  # 引数を追加
+        # return colored(f"Function '{name}' defined", "magenta")
+        highlighted_function = self.highlight_syntax(function_expression)
+        return colored(f"Function '{name}' defined: ", "magenta") + highlighted_function
+
+    def process_variable_assignment(self, expression):
+        name, value_expression = [s.strip() for s in expression.split("=", 1)]
+        print(name, value_expression)
+        if name in self.operator:
+            raise ValueError(f"Invalid variable name '{name}'")
+        self.validate_name(name)
+        value = self.evaluate(value_expression)[0]
+        self.assign_variable(name, value)
+        # return colored(f"Variable '{name}' assigned with value {value}", "blue")
+        highlighted_value_expression = self.highlight_syntax(value_expression)
+        return colored(f"Variable '{name}' assigned with value {value}: ", "blue") + highlighted_value_expression
+
+    def process_expression(self, expression):
+        if "=>" in expression:  # 関数定義
+            return self.process_function_definition(expression)
+        elif re.search(r"\b\w+\s*=(?!=)", expression): # 代入処理
+            return self.process_variable_assignment(expression)
+        else:  # RPN式の評価と結果の表示
+            ans = self.evaluate(expression, stack=self.stack)
+            return colored(f"{ans}", "green")
+
+
+class ExecutionMode:
+    def __init__(self, rpn_calculator: Stacker):
+        self.rpn_calculator = rpn_calculator
+        self._operator_key = list(self.rpn_calculator.operator.keys())
+        self._variable_key = list(self.rpn_calculator.variables.keys())
+        self._reserved_word = copy.deepcopy(self.rpn_calculator.reserved_word)
+        self._reserved_word = (self._reserved_word + self._operator_key + self._variable_key)
+        self.completer = WordCompleter(self._reserved_word)
+
+    def get_multiline_input(prompt=""):
+        lines = []
+        while True:
+            line = input(prompt)
+            if line.endswith("\\"):
+                line = line[:-1]  # バックスラッシュを取り除く
+                lines.append(line)
+                prompt = ""  # 2行目以降のプロンプトは空にする
+            else:
+                lines.append(line)
+                break
+        return "\n".join(lines)
+
+    def run(self):
+        raise NotImplementedError("Subclasses must implement the 'run' method")
+
+
+class InteractiveMode(ExecutionMode):
+    def run(self):
+        line_count = 0
+        while True:
+            try:
+                expression = prompt(
+                    f"stacker:{line_count}> ",
+                    history=FileHistory(history_file_path),
+                    completer=self.completer,
+                )
+
+                # ダブルコーテーションまたはシングルコーテーションで始まる入力が閉じられるまで継続する処理
+                while (
+                    (expression.startswith('"') and expression.count('"') % 2 != 0) or
+                    (expression.startswith("'") and expression.count("'") % 2 != 0)
+                ):
+                    next_line = input(f"stacker:{line_count}> ")
+                    expression += "\n" + next_line
+
+                if expression.lower() == "exit":
+                    break
+                if expression.lower() == "help":
+                    show_help()
+                    continue
+                if expression.lower() == "about":
+                    show_about()
+                    continue
+                if expression.lower() == "delete_history":
+                    delete_history()
+                    continue
+                if expression.lower() == "clear":
+                    self.rpn_calculator.clear_stack()
+                    continue
+
+                stack_str = self.rpn_calculator.process_expression(expression)
+                print(stack_str)  # stackを全表示
+
+            except Exception as e:
+                print(colored(f"[ERROR]: {e}", "red"))
+                # print("Please enter a valid RPN expression, variable assignment, or function definition.")
+
+            line_count += 1
+
+
+class ScriptMode(ExecutionMode):
+    def __init__(self, rpn_calculator, filename):
+        super().__init__(rpn_calculator)
+        self.filename = filename
+
+    def run(self):
+        with open(self.filename, 'r') as file:
+            for line in file:
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+
+                try:
+                    result = self.rpn_calculator.process_expression(line)
+                    print(result)
+                except Exception as e:
+                    print(f"Error: {e}")
+
+
+def main():
+    show_top()
+
+    rpn_calculator = Stacker()
+
+    # 機能拡張予定
+    # if len(sys.argv) > 1:  # 追加
+    #     script_filename = sys.argv[1]
+    #     # スクリプトモードの実行
+    #     script_mode = ScriptMode(rpn_calculator, script_filename)
+    #     script_mode.run()
+    # else:
+    #     # インタラクティブモードの実行
+    #     interactive_mode = InteractiveMode(rpn_calculator)
+    #     interactive_mode.run()
+
+    # インタラクティブモードの実行
+    interactive_mode = InteractiveMode(rpn_calculator)
+    interactive_mode.run()
+
+
+if __name__ == "__main__":
+    main()

stacker/test.py

@@ -0,0 +1,102 @@
+import cmath
+import math
+import unittest
+
+from stacker import Stacker
+
+
+def cpow(x1, x2):
+    return cmath.exp(x2 * cmath.log(x1))
+
+
+class TestStacker(unittest.TestCase):
+    def setUp(self):
+        self.stacker = Stacker()
+
+    def test_arithmetic_operations(self):
+        test_cases = [
+            ("2 3 +", 5),
+            ("10 3 -", 7),
+            ("4 6 *", 24),
+            ("12 4 /", 3),
+            ("7 2 //", 3),
+            ("9 2 %", 1),
+            ("5 neg", -5),
+            ("-3 abs", 3),
+            ("3 2 ^", 9),
+            ("3 exp", math.exp(3)),
+            ("2 log", math.log(2)),
+            ("30 radians sin", math.sin(math.radians(30))),
+            ("45 radians cos", math.cos(math.radians(45))),
+            ("60 radians tan", math.tan(math.radians(60))),
+            ("5 float", 5.0),
+            ("3.14 int", 3),
+            ("1 1 ==", True),
+            ("1 0 !=", True),
+            ("1 2 <", True),
+            ("3 3 <=", True),
+            ("2 1 >", True),
+            ("3 3 >=", True),
+            ("true false and", False),
+            ("true false or", True),
+            ("true not", False),
+            ("3 2 band", 3 & 2),
+            ("3 2 bor", 3 | 2),
+            ("3 2 bxor", 3 ^ 2),
+            ("4 2 gcd", math.gcd(4, 2)),
+            ("4 log10", math.log10(4)),
+            ("4 log2", math.log2(4)),
+            ("4 !", math.factorial(4)),
+            ("9 sqrt", math.sqrt(9)),
+            ("3.2 ceil", math.ceil(3.2)),
+            ("3.8 floor", math.floor(3.8)),
+            ("3.5 round", round(3.5)),
+            ("3.51 1 roundn", round(3.51, 1)),
+            # Add complex number test cases
+            ("1+2j 2+3j +", complex(1, 2) + complex(2, 3)),
+            ("1+2j 2+3j -", complex(1, 2) - complex(2, 3)),
+            ("1+2j 2+3j *", complex(1, 2) * complex(2, 3)),
+            ("1+2j 2+3j /", complex(1, 2) / complex(2, 3)),
+            ("1+2j 2 ^", cpow(complex(1, 2), 2)),
+            ("1+2j exp", cmath.exp(complex(1, 2))),
+            ("1+2j log", cmath.log(complex(1, 2))),
+            ("1+2j sin", cmath.sin(complex(1, 2))),
+            ("1+2j cos", cmath.cos(complex(1, 2))),
+            ("1+2j tan", cmath.tan(complex(1, 2))),
+            ("1+2j sqrt", cmath.sqrt(complex(1, 2))),
+            ("1+2j sinh", cmath.sinh(complex(1, 2))),
+            ("1+2j cosh", cmath.cosh(complex(1, 2))),
+            ("1+2j tanh", cmath.tanh(complex(1, 2))),
+            ("1+2j asin", cmath.asin(complex(1, 2))),
+            ("1+2j acos", cmath.acos(complex(1, 2))),
+            ("1+2j atan", cmath.atan(complex(1, 2))),
+            ("1+2j asinh", cmath.asinh(complex(1, 2))),
+            ("1+2j acosh", cmath.acosh(complex(1, 2))),
+            ("1+2j atanh", cmath.atanh(complex(1, 2))),
+        ]
+
+        for expression, expected in test_cases:
+            self.stacker.stack.clear()
+            self.stacker.process_expression(expression)
+            self.assertEqual(self.stacker.stack[-1], expected)
+
+        # for expression, expected in test_cases:
+        #     self.stacker.stack.clear()
+        #     self.stacker.process_expression(expression)
+        #     self.assertAlmostEqual(self.stacker.stack[-1], expected)
+        print("!")
+
+    def test_variable_assignment(self):
+        self.stacker.stack.clear()
+        self.stacker.process_expression("a = 5")
+        self.assertEqual(self.stacker.variables["a"], 5)
+
+    def test_function_definition_and_call(self):
+        self.stacker.stack.clear()
+        self.stacker.process_expression("x square => x x *")
+        self.stacker.process_expression("4 square")
+        self.assertEqual(self.stacker.stack[-1], 16)
+
+
+if __name__ == "__main__":
+    unittest.main()