乙Py先生のプログラミング教室
初学者のためのプログラミング学習サイト

プログラミング

今回はGeoPandasとFoliumによる
地理データの取り扱い方です。


解説動画はこちら


 
Pythonで地理データを取り扱う方法


今回は地理データを取り扱う方法として
2つのライブラリをご紹介します。


GeoPandas

Pandasライブラリに
空間(Geometry)を実現したライブラリ

Pandasの DataFrame を拡張
各行に 1つのジオメトリ(形状) を持つ
GIS(地理情報システム)向けの演算が可能
静的なplotが行える


Folium

Leaflet.js を
Python から操作する描画用ライブラリ

出力は HTML
OpenStreemMapをタイルレイヤとして表示できる
Jupyter / Web / 静的ファイルで使える
インタラクティブな描画が行える

ということでこの2つを用いて
地理データを描画していきましょう。



GeoPandasを用いた地理描画

最初はGeoPandasを用いた描画です
Google colabで実行できるコードになっていますが
Google colabでは日本語が取り扱えないので
別途ライブラリが必要です。


ライブラリのインストール

日本語を使用するため
japanize-matplotlib
をインストールしておきます。
pip install japanize-matplotlib


架空のデータを読み込んで描画する


まず初めは、何もない状態から
架空のデータを使っていきます。

pandasに読み込んだ後
GeoPandasに緯度経度として読み込みします。
# -----------------
# 1. データの準備 (架空のオープンデータ)
# -----------------

# (A) 地理データ: 都道府県庁所在地のポイントデータ (GeoJSONを想定)
# 緯度・経度と都道府県名が含まれるGeoDataFrameを作成
data_geo = {
    'city': ['Sapporo', 'Sendai', 'Tokyo', 'Nagoya', 'Osaka', 'Fukuoka'],
    'prefecture': ['北海道', '宮城', '東京', '愛知', '大阪', '福岡'],
    'latitude': [43.06, 38.27, 35.69, 35.18, 34.69, 33.59],
    'longitude': [141.35, 140.87, 139.69, 136.91, 135.50, 130.40]
}
df_geo = pd.DataFrame(data_geo)

# GeoDataFrameに変換
# 'geometry'カラムを作成し、緯度・経度からポイント(点)の地理情報を持たせる
gdf_city = gpd.GeoDataFrame(
    df_geo,
    geometry=gpd.points_from_xy(df_geo.longitude, df_geo.latitude),
    crs="EPSG:4326"
)
print("GeoDataFrameの確認:\n", gdf_city.head())
GeoDataFrameの確認:
       city prefecture  latitude  longitude              geometry
0  Sapporo        北海道     43.06     141.35  POINT (141.35 43.06)
1   Sendai         宮城     38.27     140.87  POINT (140.87 38.27)
2    Tokyo         東京     35.69     139.69  POINT (139.69 35.69)
3   Nagoya         愛知     35.18     136.91  POINT (136.91 35.18)
4    Osaka         大阪     34.69     135.50   POINT (135.5 34.69)


データに少し加工を加え、情報を足します。
# (B) 属性データ: 都道府県ごとの人口データ
# 都道府県ごとの人口属性データフレーム
data_attr = {
    'prefecture': ['北海道', '宮城', '東京', '愛知', '大阪', '福岡'],
    'population_mil': [5.2, 2.3, 14.0, 7.5, 8.8, 5.1], # 単位: 百万人
    'density_class': ['Low', 'Mid', 'High', 'High', 'High', 'Mid']
}
df_attr = pd.DataFrame(data_attr)

# -----------------
# 2. データの結合 (Merge)
# -----------------
# 'prefecture'カラムをキーにしてGeoDataFrameと属性データを結合
gdf_merged = gdf_city.merge(df_attr, on='prefecture')
print("\n結合後のGeoDataFrameの確認:\n", gdf_merged[['prefecture', 'population_mil', 'geometry']].head())
結合後のGeoDataFrameの確認:
   prefecture  population_mil              geometry
0        北海道             5.2  POINT (141.35 43.06)
1         宮城             2.3  POINT (140.87 38.27)
2         東京            14.0  POINT (139.69 35.69)
3         愛知             7.5  POINT (136.91 35.18)
4         大阪             8.8   POINT (135.5 34.69)


次のコードで簡易なプロットを行えます。
# 結合したデータを基にGeoPandasで簡易プロット
gdf_merged.plot(column='population_mil', legend=True, figsize=(5, 5),
                markersize=gdf_merged['population_mil'] * 10)
plt.title("GeoPandasによる簡易プロット (人口規模)")
plt.show()
スクリーンショット 2025-12-13 17.24.29

緯度経度だけを用いて描画していますが
これだけだと、あまり意味がない描画ですね

これをFoliumで描画しなおします。
# Foliumの描画準備 (日本の中心付近にマップを初期化)
map_center = [35.68, 139.69] # 東京の緯度・経度
m = folium.Map(location=map_center, zoom_start=5)

# -----------------
# 1. シンプルなマーカー表示 (庁所在地)
# -----------------
for idx, row in gdf_merged.iterrows():
    # ポップアップに表示する情報をHTMLで作成
    html = f"""
        

{row['prefecture']}庁所在地

人口: {row['population_mil']}百万人

密度区分: {row['density_class']}

""" iframe = folium.IFrame(html) popup = folium.Popup(iframe, min_width=200, max_width=300) # Markerを追加 folium.Marker( location=[row.latitude, row.longitude], popup=popup, icon=folium.Icon(color='blue', icon='info-sign') ).add_to(m) # ----------------- # 2. ヒートマップの追加 (人口密度に応じて色を濃く) # ----------------- from folium.plugins import HeatMap # HeatMapに必要なデータ形式: [[緯度, 経度, 強度], ...] # 強度として人口(百万)を使用 heat_data = [[row.latitude, row.longitude, row.population_mil] for idx, row in gdf_merged.iterrows()] HeatMap(heat_data).add_to(m) # ----------------- # 3. GeoPandasとFoliumを組み合わせた応用描画 # Foliumでは、CircleMarkerを使って、データを視覚的に表現できます。 def get_color(density): if density == 'High': return 'red' elif density == 'Mid': return 'orange' else: return 'green' for idx, row in gdf_merged.iterrows(): folium.CircleMarker( location=[row.latitude, row.longitude], radius=row['population_mil'] * 1.5, # 人口規模に応じて円の大きさを変更 color=get_color(row['density_class']), fill=True, fill_color=get_color(row['density_class']), fill_opacity=0.7, tooltip=f"{row['prefecture']}: {row['population_mil']}M" ).add_to(m) # マップをHTMLファイルとして保存 m.save("interactive_map.html") print("\nFoliumマップオブジェクトを作成しました。")

Foliumでは作った地図を
静的なHTMLとして保存ができます。

Google Colabでは
デフォルトのフォルダに
HTMLファイルが出力されると思います。

変数 m を実行すると
中身を描画することもできます。

スクリーンショット 2025-12-13 17.21.28

こんな感じで、架空のデータですが
地図上に描画できました。

Foliumはインタラクティブに操作できるので
色々遊べます。



500キロメートル圏内を描画する


GeoPandasで緯度経度から少し計算して
描画用のデータを作ることができます。

まずは距離を測るためのCRSというデータへ変換します。
# -----------------
# 1. CRSの変換 (距離計算のため)
# -----------------
# 緯度・経度 (4326) からメートル単位のCRS (3857) へ変換
gdf_projected = gdf_merged.to_crs("EPSG:3857")
print("\nCRS変換後のGeoDataFrame (EPSG:3857):\n", gdf_projected.head())
       city prefecture  latitude  longitude                          geometry  \
0  Sapporo        北海道     43.06     141.35  POINT (15735010.024 5321108.922)   
1   Sendai         宮城     38.27     140.87  POINT (15681576.668 4617638.286)   
2    Tokyo         東京     35.69     139.69  POINT (15550219.669 4258049.263)   
3   Nagoya         愛知     35.18     136.91  POINT (15240751.485 4188369.409)   
4    Osaka         大阪     34.69     135.50  POINT (15083791.002 4121832.777) 



これで計算する用意ができたので
Foliumにデータを加えます。
# -----------------
# 2. バッファリング (空間分析)
# -----------------
# 東京、大阪、名古屋の庁所在地から「500km圏内」のバッファを作成
# 単位はメートルなので 500 * 1000 = 500,000メートル
buffer_distance = 500 * 1000

# GeoPandasのbuffer()メソッドでバッファを作成
# わかりやすさのため、東京の行(index=2)のみを抽出
tokyo_buffer = gdf_projected.iloc[[2]].buffer(buffer_distance)

# バッファを元のCRS (4326) に戻し、Foliumで表示できるようにする
tokyo_buffer_wgs84 = tokyo_buffer.to_crs("EPSG:4326")

# -----------------
# 3. Foliumでの分析結果の可視化
# -----------------

# 新しいFoliumマップを作成
m_analysis = folium.Map(location=map_center, zoom_start=5)

# バッファリング結果 (Polygon) をFoliumに描画
folium.GeoJson(
    tokyo_buffer_wgs84.__geo_interface__, # GeoPandasオブジェクトをGeoJSON互換の形式に変換
    name='500km Buffer from Tokyo',
    style_function=lambda x: {
        'fillColor': 'purple',
        'color': 'purple',
        'weight': 2,
        'fillOpacity': 0.3
    }
).add_to(m_analysis)

# マーカーとヒートマップも再表示 (任意)
for idx, row in gdf_merged.iterrows():
    folium.Marker(
        location=[row.latitude, row.longitude],
        popup=f"{row['prefecture']} - {row['population_mil']}M"
    ).add_to(m_analysis)

# マップにレイヤー切り替え機能を追加して見やすくする
folium.LayerControl().add_to(m_analysis)
m_analysis.save("analysis_map.html")

今度は m_analysis という変数の中身を見てみると
スクリーンショット 2025-12-13 17.22.35

こんな感じで東京から500キロメートル圏内を
塗ることができました。



CSVファイルを読み込みして描画する


今度は架空ではなく
実際のデータで描画してみましょう。

地震のデータがあるので
これを用います。

地震データの取得先
https://www.data.jma.go.jp/eqdb/data/shindo/

このサイトから検索して
CSVファイルにして
Google Colabのファイル置き場に配置します。

CSVを読み込みします。
import pandas as pd
import folium
from folium.plugins import MarkerCluster
from io import StringIO
import re

# ----------------------------------------------------
# 1. データ準備
# ----------------------------------------------------
csv_data = """地震の発生日,地震の発生時刻,震央地名,緯度,経度,深さ,M,最大震度
2025/12/10,23:52:24.1,青森県東方沖,40°50.1′N,142°45.3′E,36 km,6.0,震度4
2025/12/09,18:09:45.9,青森県東方沖,41°16.0′N,142°25.1′E,47 km,5.3,震度3
2025/12/09,06:52:42.7,青森県東方沖,40°56.6′N,143°18.0′E,15 km,6.6,震度4
2025/12/09,03:56:29.5,青森県東方沖,40°57.0′N,143°07.6′E,19 km,6.1,震度3
2025/12/08,23:33:39.2,青森県東方沖,40°53.0′N,142°35.2′E,42 km,5.9,震度3
2025/12/08,23:15:10.1,青森県東方沖,40°58.0′N,142°17.2′E,54 km,7.5,震度6強
2025/12/05,12:11:24.1,熊本県阿蘇地方,32°58.5′N,131°06.8′E,4 km,3.3,震度3
"""
# df = pd.read_csv(StringIO(csv_data))
df = pd.read_csv('地震リスト.csv')
df.head(3)<
地震の発生日 地震の発生時刻 震央地名 緯度 経度 深さ 最大震度
0 2025/12/10 23:52:24.1 青森県東方沖 40°50.1′N 142°45.3′E 36 km 6.0 震度4
1 2025/12/09 18:09:45.9 青森県東方沖 41°16.0′N 142°25.1′E 47 km 5.3 震度3
2 2025/12/09 06:52:42.7 青森県東方沖 40°56.6′N 143°18.0′E 15 km 6.6 震度4


緯度経度などのデータが
そのままでは使えないので加工します。

def convert_dms_to_decimal(dms_str):
    """ '40°50.1′N' のような文字列を十進数形式に変換する関数 """
    match = re.match(r"(\d+)°(\d+\.?\d*)′([NSEW])", dms_str)
    if not match:
        return None
    
    degrees = float(match.group(1))
    minutes = float(match.group(2))
    direction = match.group(3)
    decimal = degrees + minutes / 60
    
    # 南緯(S)と西経(W)はマイナスにする
    if direction in ('S', 'W'):
        decimal *= -1  
    return decimal

# 緯度と経度を数値に変換
df['緯度_dec'] = df['緯度'].apply(convert_dms_to_decimal)
df['経度_dec'] = df['経度'].apply(convert_dms_to_decimal)

# 震度を強度順に数値化するための辞書
shindo_mapping = {
    '震度1': 10,
    '震度2': 20,
    '震度3': 30,
    '震度4': 40,
    '震度5弱': 51,
    '震度5強': 55,
    '震度6弱': 61,
    '震度6強': 65,
    '震度7': 70,
}

# 震度を数値に変換
df['shindo_value'] = df['最大震度'].map(shindo_mapping)

def get_shindo_color(shindo):
    # 震度値 (30, 40, ..., 70) を利用
    if shindo >= 65:  # 震度6強, 震度7
        return 'darkred'
    elif shindo >= 55: # 震度5強, 震度6弱
        return 'red'
    elif shindo >= 51: # 震度5弱
        return 'orange'
    elif shindo >= 40: # 震度4
        return 'lightred'
    elif shindo >= 30: # 震度3
        return 'green'
    else:
        return 'gray' # その他

描画を行います。
# ----------------------------------------------------
# 1. Folium マップの作成
# ----------------------------------------------------
# 日本の中心付近を初期位置とする
map_center = [df['緯度_dec'].mean(), df['経度_dec'].mean()]
m = folium.Map(location=map_center, zoom_start=5)

# ----------------------------------------------------
# 2. 震度ごとに FeatureGroup (レイヤー) を作成
# ----------------------------------------------------

# 震度レベルごとの FeatureGroup を格納する辞書
shindo_layers = {}

# 震度マッピングのキー(例: '震度7', '震度6強')を降順でソート
sorted_shindo_levels = sorted(shindo_mapping.keys(), key=lambda x: shindo_mapping[x], reverse=True)

for shindo_level in sorted_shindo_levels:
    # レイヤー名を設定 (LayerControlに表示される名前)
    layer_name = f"最大震度: {shindo_level}"
    # FeatureGroupを作成し、マップに追加
    fg = folium.FeatureGroup(name=layer_name, show=True).add_to(m)
    shindo_layers[shindo_level] = fg

# ----------------------------------------------------
# 3. データの反復処理と適切なレイヤーへのマーカー追加
# ----------------------------------------------------
for idx, row in df.iterrows():
    datetime_full = f"{row['地震の発生日']} {row['地震の発生時刻'][:8]}"
    
    # ポップアップ情報
    popup_html = f"""
        **最大震度: {row['最大震度']}**
発生日時: {datetime_full}
震央地名: {row['震央地名']}
深さ: {row['深さ']}
マグニチュード(M): {row['M']}
""" marker_color = get_shindo_color(row['shindo_value']) current_shindo_level = row['最大震度'] # 該当する震度の FeatureGroup を取得 target_fg = shindo_layers.get(current_shindo_level) if target_fg is not None: # マーカーを対応する FeatureGroup に追加 folium.Marker( location=[row['緯度_dec'], row['経度_dec']], popup=popup_html, icon=folium.Icon(color=marker_color, icon='flash', prefix='fa') ).add_to(target_fg) # ---------------------------------------------------- # 4. LayerControl (表示切り替えボックス) を追加 # ---------------------------------------------------- folium.LayerControl(collapsed=False).add_to(m) # ---------------------------------------------------- # 5. マップの保存と表示 # ---------------------------------------------------- m.save("earthquake_layer_control_map.html") print("震度別表示切り替え機能付きFoliumマップの作成が完了しました。")

変数 m を表示してみると
スクリーンショット 2025-12-13 17.21.43


震度ごとに表示を切り替えすることができます。





まとめ

GeoPandasで計算して、Foliumで描画すると
以下のような分析が簡単に行えます。

商圏分析
人口ヒートマップ
配送ルート可視化
不動産マップ
災害・危険区域表示

これらの分析を行う際に
このライブラリの組み合わせは
非常に捗ります。

かなり便利なので
使ってみると面白いと思います
それでは。


AI計算資源の覇権はどっちになるのか
NVIDIA GPU vs Google TPU
という内容で動画を作りました。

解説動画はこちら

 
個人的にはGemini Pro 3 が
恐ろしく役立っているので
TPU勢力拡大の構図は見えました。


今回はGoogleの新しいAIエージェント搭載エディター
Antigravity のご紹介です


解説動画はこちら




Google Antigravityとは

Google が 2025-11-18に発表した
エージェントファーストの開発プラットフォーム(IDE)
VS-CODEがベース



主な特徴

VS-CODEと同様のインターフェースで
エージェントファースト開発体験

エディタ・ターミナル・ブラウザを横断して
タスクを自律的に遂行できる



マネージャービューとエディタビュー

「マネージャービュー」では
複数ワークスペース・複数エージェントを一元管理し
各エージェントの進行状況や成果物を俯瞰できる

「エディタビュー」では
従来のコード編集画面に近い操作感の中で
エージェントとの対話や修正も行える



インストール方法

以下のサイトよりダウンロード
ダウンロード先


対象OS
MacOS
Windows
Linux

MacOSは
ダウンロード後に
imgファイルを開いてドラッグ



利用方法

ソフトウェアを開くのみ

初回起動時
Agent利用方法は選択式
「Agent-assisted development」 を選択

Agent利用はGoogleアカウントが必要
未作成の人は要作成
アカウントある人はログインが必要



日本語化の方法

1
左側メニューのExtensionから
Japanese Language Pack for Visual Studio Code
を探してインストールする

インストールが失敗して手動でインストールする場合は
MS-CEINTL.vscode-language-pack-ja-x.xxx.x.vsix
を手動ダウンロードしてから

Extensionメニューの ... マークから
Install From VSIX を選択してファイルを選択してインストールする


2
Shift + Command + P でメニューを開き
Configure Display Language を選択
対応言語から ja を選択して再起動する



その他設定

ブラウザーのChrome 拡張機能である
Antigravity Browser Extension 
をインストールしておくと便利(Chrome用)
(ブラウザー実行時にAntigravityが起動する)

回答を日本語にしてもらう

Agentパネル右上の「…」から
「Customizations → Rules → +Global」で
「日本語で回答してください」と設定



使い方

Editorモード
初期使用はこのモード
VS-CODEと同様のインターフェースでコードを編集する

利用できるエージェント
gemini 3 pro(High)
gemini 3 pro(Low)
Claude Sonnet 4.5
Claude Sonnet 4.5 (Thinking)
GPT-OSS 120B(Midium)


利用モード
Planning : 複雑タスク向け
FAST : シンプルタスク向け



エージェントの利用料金

現在は無料のパブリックプレビュー版のため料金なし
ただし、利用制限はあり
(クォータは5時間ごとにリフレッシュされるが)



Agent Managerモード

「⌘E」で「Agent Manager」に切り替えできる
今回は利用方法は割愛



早速作ってみる

gemini pro で回答してもらいました

数独ゲームを作ってみるプロンプト

数独ゲームを実行することのできる
sudoku.htmlを作成して下さい

以下の仕様にてJavascriptで数独ゲームを作成してください

# 仕様
画面中央に 9x9 マスの数独版を表示し
初期配置は30マス分を表示する
入力用の数字選択用の入力ボックスを数独版の下に配置する
入力ボックスは1~9の数字と、消去用のボタンを配置する
入力ボックスの数字を選択した状態で
数独版のマスをクリックすることで
数独版の該当マスに
入力した数字を表示する
数独版の該当マスをクリックすることで
数独版の該当マスの数字を消去する
全てのマスを埋めることで数独ゲームを完了する
数独ゲームを完了したら
数独版の下に数独を完了したことを表示する

リスキーダイスを作ってみるプロンプト

以下の仕様にてJavascriptでサイコロゲームを作成してください
risky_dice.htmlを作成して下さい

# 仕様
画面中央に 正20面体 のサイコロを表示する
サイコロの1面だけが「大凶」、残りの19面が「大吉」と文字列を表示させる
サイコロの下に「サイコロを降る」ボタンを配置して
クリックしたらサイコロを降ることができる
サイコロを降ったらサイコロの面の文字列を表示する
「大凶」の場合はゲームオーバーのポップアップを表示する



まとめ

まだプレビュー版のため
エージェント利用枠などが低く
お試し利用しかできていないですね

ただgemini pro を無料でも
IDEで使用できるのは大きいです

エージェントモードの詳しい使い方などが
分かり次第、また解説していきたいと思います。






今回はドラクエ1・2リメイククリア記念として
ドラクエ4のコインバグについてやっていきたいと思います。


解説動画はこちら



ドラクエ4とは

ドラゴンクエストIV 導かれし者たち
1990年2月11日にエニックス(合併前)から発売された
ファミリーコンピュータ用ロールプレイングゲーム
『ドラゴンクエストシリーズ』の第4作目

5つの章に分かれたシナリオ、AIによる戦闘システムや
5人以上の仲間キャラクターと同時に
冒険できる馬車システムが導入された作品

ゲームの2,3,5章にはミニゲームとしてカジノがあり
そこではコインバグが使える部分がありました




ドラクエ4のカジノシステムと「コインバグ」

ゲーム内の2,3,5章でいける大都市エンドール
この都市にはカジノがあり、コインが買える

1枚の価格
2章 : 10ゴールド
3章 : 200ゴールド
5章 : 20ゴールド

第3章ではコイン83,887枚を184ゴールドで
第5章では838,861枚を4ゴールドで購入できる

これはワークエリアの算術オーバーフローに起因する判定処理のバグが原因

購入金額の計算を3バイトで行っているため、カジノでコインを購入する際
計算金額が16,777,215ゴールドを超えるとオーバーフローが発生
(2 ** 24 = 16777216)

本来のコインの金額と16777216との差が
購入金額となっていたようです



ファミコンの当時のハードウェア情報


CPU:Ricoh 2A03(6502の派生)
メモリ構造:8bit CPU・少ないRAM

参考 : PS5のCPU:64ビット、スーパーファミコンのCPU:16ビット

ソフト開発はアセンブリ言語を使用
数値の表現方法(8bit × n バイトで多バイト値を管理)
多バイト演算が必要(24bit/32bitの値を手動で扱う)

スプライト制限・PPUなど
制約だらけの開発環境だったようです



ファミコン的な多バイト計算のしくみ


当時の 8bit CPU は一度に扱えるのは 0..255(1バイト)だけ
大きな数は複数バイトに分割して管理する

例:24ビット値は
LO(下位8ビット)
MID(中位8ビット)
HI(上位8ビット)という3バイトで保持


「足し算」は常に低位バイト→高位バイトの順に行い
各段で キャリー(繰り上がり) を次の段へ渡す:
LO = LO1 + LO2 → もし >255 なら carry=1 で LO &= 0xFF
MID = MID1 + MID2 + carry → 同様に繰り上げ
HI = HI1 + HI2 + carry → 最終的にさらに繰り上がれば(HI が 8bit を越える)

その上位のバイトが必要になるが、実装次第で捨てられる


乗算」は 8bit CPU で直接1回の命令で出来ないため
一般に次のどちらかで実装:

1.部分積の加算(schoolbook):
各バイトを8bit×8bitで掛けて(最大16bitの部分積)
適切に桁(バイト)シフトして加算する

2.繰り返し加算(加算を price 回繰り返す):
result = 0;
for i in range(count):
    result += price のようにして加える
(実際はより効率的なシフト+加算で実装されることが多い)


オーバーフローが起きる理由

ゲーム側が「結果を格納する領域」を
3 バイト(24ビット)だけ確保していると
数学的に 24 ビットを超える値は
自動的に上位ビットが切り捨てられる
(つまり結果は result mod 2^24)
これがバグの本質



838,861 × 20 がなぜ 4 になるか

1.コイン枚数(24bit)をバイトに分解:
コイン枚数 = 838,861
LO = 205 = 0xCD
MID = 204 = 0xCC
HI = 12  = 0x0C
検算: 12 * 65536 + 204 * 256 + 205
= 786432 + 52224 + 205 = 838861


2.各バイトの部分積を求める(コイン価格 = 20)
p0 = LO * 20 = 205 * 20 = 4,100 → hex 0x1004
  →bytes = [0x04, 0x10, 0x00, 0x00]
p1 = MID * 20 = 204 * 20 = 4,080 → hex 0x0FF0 → shift 1 byte
  → bytes = [0x00, 0xF0, 0x0F, 0x00]
p2 = HI * 20 = 12  * 20 = 240   → hex 0x00F0 → shift 2 bytes
  → bytes = [0x00, 0x00, 0xF0, 0x00]

3.部分積を下位バイトから順に加算(変数 acc は 4 バイトで保持):

初期
acc = [0x00, 0x00, 0x00, 0x00]

加算 p0
acc = [0x04, 0x10, 0x00, 0x00]


加算 p1:
acc[0] += 0x00 → 0x04
acc[1] += 0xF0 → 0x10 + 0xF0 = 0x100 -> acc[1]=0x00, carry=1
acc[2] += 0x0F + carry -> 0x00 + 0x0F + 1 = 0x10
acc[3] += 0x00 -> 0x00
→ acc = [0x04, 0x00, 0x10, 0x00]

加算 p2:
acc[0] += 0x00 -> 0x04
acc[1] += 0x00 -> 0x00
acc[2] += 0xF0 -> 0x10 + 0xF0 = 0x100 -> acc[2]=0x00, carry=1
acc[3] += 0x00 + carry -> 0x00 + 1 = 0x01
→ acc = [0x04, 0x00, 0x00, 0x01]


4.acc を 32bit で読むと 0x01000004
( 0x01000004 = 16,777,220)

ゲームはここで下位3バイトのみ(0x000004)を保存
→ 0x000004 = 4 が実際にストアされる

数学的には 838,861 * 20 = 16,777,220 だが
16,777,220 mod 2^24 = 4 となり
格納領域(24bit)に収めると 4 になる


Pythonで再現する「疑似アセンブリ」計算コード


当時のファミコンで行われていたであろう計算を
Pythonで模したコードが以下です。
# --- ユーティリティ(24bit <-> 3バイト変換) ---
def to_bytes24(n: int):
    """整数 -> (lo, mid, hi) の3バイト"""
    mask24 = (1 << 24) - 1
    n &= mask24 # 24ビットに制限(実機での格納に相当)
    lo = n & 0xFF
    mid = (n >> 8) & 0xFF
    hi = (n >> 16) & 0xFF
    return lo, mid, hi

def from_bytes24(b):
    lo, mid, hi = b
    return lo | (mid << 8) | (hi << 16)

# --- 8bit 加算(キャリーを明示) ---
def add_with_carry(a: int, b: int, carry_in: int = 0):
    """8bitの加算 -> (結果8bit, carry_out)"""
    s = a + b + carry_in
    result8 = s & 0xFF
    carry_out = 1 if s > 0xFF else 0
    return result8, carry_out

# --- 24bit のバイト単位加算(LO->MID->HI の順でキャリーを伝播) ---
def add24(a_bytes, b_bytes):
    al, am, ah = a_bytes
    bl, bm, bh = b_bytes
    rl, c = add_with_carry(al, bl, 0) # LO を足す(6502での ADC 命令相当)
    rm, c = add_with_carry(am, bm, c) # MID に carry を足す
    rh, c = add_with_carry(ah, bh, c) # HI に carry を足す
    return (rl, rm, rh)

# --- 部分積を使った 24bit x 8bit の乗算(8bit CPU の実装を模倣) ---
def mul24_by_8_partial(count_bytes, price8):
    """
    count_bytes は (lo, mid, hi) の3バイト。
    price8 は 0..255 の 8bit 単価。
    実行は:
      1) 各バイト * price を計算(部分積) -> 最大16bit
      2) それらを適切にシフト(バイト単位)して 4 バイト長の accumulator に足す
      3) 最終的に下位3バイトだけを保存
    """
    lo, mid, hi = count_bytes

    # 各バイトの部分積(16bitまで)
    p0 = lo  * price8   # 部分積0, shift 0 bytes
    p1 = mid * price8   # 部分積1, shift 1 byte (<<8)
    p2 = hi  * price8   # 部分積2, shift 2 bytes (<<16)

    # 各部分積をバイト配列(4バイト:下位から)に展開して加算
    def to_4bytes_le(x):
        return (x & 0xFF, (x >> 8) & 0xFF, (x >> 16) & 0xFF, (x >> 24) & 0xFF)

    # shift としてバイト単位で位置をずらす(p1 は 1 バイトシフト、p2 は 2 バイト)
    b0 = to_4bytes_le(p0)        # p0 << 0
    b1 = to_4bytes_le(p1 << 8)   # p1 << 8  -> 実際は p1 の下位を一つ上のバイトにずらす
    b2 = to_4bytes_le(p2 << 16)  # p2 << 16

    # 4バイト幅で逐次加算(8bit CPU の ADC の連鎖を模倣)
    acc = (0,0,0,0)
    for part in (b0, b1, b2):
        acc = add_4bytes_le(acc, part)

    # 実機が保存するのは下位3バイトのみ(= acc の 0..2 バイト)
    stored24 = (acc[0], acc[1], acc[2])
    return stored24

# 補助:4バイト加算(下位からキャリーを伝える)
def add_4bytes_le(a4, b4):
    r0, c = add_with_carry(a4[0], b4[0], 0)
    r1, c = add_with_carry(a4[1], b4[1], c)
    r2, c = add_with_carry(a4[2], b4[2], c)
    r3, c = add_with_carry(a4[3], b4[3], c)
    return (r0, r1, r2, r3)


簡単に計算できるようにしたコードだとこうなります
当時のFCDQ4のコイン価格を計算してみると
# コイン価格のシミュレーションコード
def simulate_24bit_mul(count, price):
    # count を 3 バイトに分解
    lo = count & 0xFF
    mid = (count >> 8) & 0xFF
    hi = (count >> 16) & 0xFF

    # 部分積
    p0 = lo * price  # fits<=0xFFFF
    p1 = mid * price
    p2 = hi * price

    # 32bit accumulator as int
    full = p0 + (p1 << 8) + (p2 << 16)

    # store as 24bit(下位24bitを取り出す)
    stored24 = full & ((1 << 24) - 1)
    return full, stored24

print(simulate_24bit_mul(100, 20))
print(simulate_24bit_mul(838_860, 20))
print(simulate_24bit_mul(838_861, 20))
print(simulate_24bit_mul(838_862, 20))
print(simulate_24bit_mul(999_999, 20))
(2000, 2000)
(16777200, 16777200)
(16777220, 4)
(16777240, 24)
(19999980, 3222764)




まとめ

ドラクエ4当時の性能では仕方ないバグだったろうと思います。

プログラミング的には相当大変な計算をしていたので
ここまでの確認が出来たかったんだろうと思います
(デバッガーや統合開発環境なさそうだし)

今は実機の性能が上がりすぎて、こういうのは無くなってきてるので
おもしろいバグとかは少なくなってますかね。

なお1990年当時
バグの噂は聞いていて知っていたので、めちゃくちゃ助かったです。
ありがとうエニックスの人!!


PS
ドラクエ1・2リメイク最高でした
ドラクエ3・1・2の流れを埋めるサブストーリー
うるさ過ぎるサマルトリア兄弟
クソ弱いローレシア王子
幼い頃にクリアできなかったので感動しました。
ありがとうスクエアエニックスの人!!





今回は投資信託の比較をするための データ抽出についてです。


解説動画はこちら


 

投資信託の成績比較


今回は投資信託の銘柄選定のために
投資信託の比較をしていきたいと思います。

データをお借りする先はこちら

みんかぶ



データを取得する

リンク先から、比較したい銘柄を選択して
「選択したファンドを比較する」ボタンをクリックすると
銘柄比較画面に飛べるので、そこのURLをコピーしておきます。

このコードでそのページのデータが取得できます。

import pandas as pd
from bs4 import BeautifulSoup
import requests
import re

url = "ここにペースト"
res = requests.get(url)


データ化する

そのままでは使いづらいので
読み込みできる形にします。
soup = BeautifulSoup(res.text, "html.parser")
table = soup.find("table",class_=re.compile("w-full border-t border-slate-300"))
trs = table.find_all("tr")
data = []
for tr in trs:
    tds = tr.find_all("td")
    tmp = []
    for td in tds:
        tmp.append(td.text.replace("\n",""))
    data.append(tmp)
   
df = pd.DataFrame(data)
df

これでデータフレームになり見やすくなりました。
ここから、使うデータだけに絞り込み整形していきます。




ファンド名、リターン、シャープレシオのみ取得する


先ほどのまでのコードで
全体のデータが取得できていたら
必要なものののみ整形します。

今回はファンド名、リターン、シャープレシオの値を使用します。

リターン、シャープレシオの値は
1,3,5年ごとの値になっているので
正規表現でうまく抜き出してデータ化します。
fand_name = data[0]
r1,r3,r5 = [],[],[]
for text in data[10]:
    pat = re.compile(
        r'(\d+)年([+-]?\d+(?:\.\d+)?%?|-)'
        r'(?=\d年|$)'
    )
    pairs = re.findall(pat, text)
    result = {int(y): float(v.replace("%","")) if v!="-" else 0 for y, v in pairs }
    r1.append(result[1])
    r3.append(result[3])
    r5.append(result[5])
    
s1,s3,s5 = [],[],[]
for text in data[11]:
    pat = re.compile(
      r'(\d+)年([+-]?\d+(?:\.\d+)?|-)'
      r'(?=\d年|$)'
    )
    pairs = re.findall(pat, text)
    result = {int(y): float(v) if v!="-" else 0 for y, v in pairs }
    s1.append(result[1])
    s3.append(result[3])
    s5.append(result[5])

df2 = pd.DataFrame()
df2["ファンド名"] = fand_name
df2["1年リターン"] = r1
df2["3年リターン"] = r3
df2["5年リターン"] = r5
df2["1年シャープレシオ"] = s1
df2["3年シャープレシオ"] = s3
df2["5年シャープレシオ"] = s5
df2

ここでうまくファンド名と数値データのみになっていれば
可視化して比較することができます。



リターンとシャープレシオで散布図にする

今回はリターンとシャープレシオを用いて比較していきます。

シャープレシオというのは

投資信託のリターン ÷ リスク(値動きのブレ)

の値で、リスクに対して
どれだけ効率的にリターンをあげているかの目安です。

シャープレシオが高い = より効率よく運用されている
ということになります。

シャープレシオが低い  = リスクを取りすぎている
とも取れます。


一般的な目安としては

シャープレシオの値評価
2.0以上非常に優れた運用成績
1.0から2.0良好な運用成績
0.5から1.0平均的な運用成績
0.5未満改善の余地がある運用成績


ということになっているようです。

早速比較してみましょう
import plotly.express as px

fig = px.scatter(
    df2,
    x="5年リターン",
    y="5年シャープレシオ",
    color="ファンド名",
    hover_name="ファンド名",
    title="ファンド別:5年リターン × 5年シャープレシオ",
)

fig.update_layout(
    xaxis_title="5年リターン (%)",
    yaxis_title="5年シャープレシオ",
    legend_title="ファンド名",
)

fig.show()
スクリーンショット 2025-11-08 16.52.42






まとめ

銘柄が多すぎて選べない際は、リターンやシャープレシオ
手数料、信託報酬などで、色々比較するのが良いです。

同じリターンなら、シャープレシオが高いものの方が
より効率良く運用されているとみなせます。

なお短期のシャープは信用度が低いので
長い期間で見るようにしましょう。


今回はここまでです
それでは

このページのトップヘ