フローティングバナーの表示制御

// フローティングバナーの表示制御
document.addEventListener('DOMContentLoaded', function () {
  const fixedEl = document.querySelector('.-fixed');
  const kvEl = document.querySelector('.sectionKv_ttl');
  const ctaEl = document.querySelector('.ctaContainerBottom_block');

  if (!fixedEl || !kvEl || !ctaEl) return;

  const kvHeight = kvEl.offsetHeight;

  function getTriggerPoint() {
    if (window.innerWidth <= 768) {
      return kvHeight * 0.25; // SP
    } else {
      return kvHeight * 0.1; // PC
    }
 

Smart Card Certificate support on domain controllers

$DCs = [System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain().DomainControllers.Name
$ScriptBlock = { Get-ChildItem -Path Cert:\LocalMachine\My | Select-Object -ExpandProperty EnhancedKeyUsageList }
Invoke-Command -ScriptBlock $ScriptBlock -ComputerName $DCs -ErrorAction SilentlyContinue | Select-Object -Property * -ExcludeProperty RunspaceId | Sort-Object -Property PSComputerName | Where-Object FriendlyName -match 'smart card' | Format-Table -AutoSize

SHELL

when we open a terminal on Unix machine - the default shell is Bash
to check type:
which $SHELL
#! - shebang

BASH - the Bourne again shell

to activate BASH from kali type:
bash

bash starts with $

BASH is also dynamic interpreted command language that can be used to write scripts
to create a custom script to add to my project create a file that ends with .sh or with no extencion:
touch filename.sh or filename


write command like:
echo "my script"

create variables:
GREET="Rita"

to access th

3025. Find the Number of Ways to Place People I

You are given a 2D array points of size n x 2 representing integer coordinates of some points on a 2D plane, where points[i] = [xi, yi]. Count the number of pairs of points (A, B), where A is on the upper left side of B, and there are no other points in the rectangle (or line) they make (including the border). Return the count.
/**
 * @param {number[][]} points
 * @return {number}
 */
var numberOfPairs = function(points) {
    let count = 0;

    // Step 1: Sort points by x ascending, then y descending
    // This ensures that for any point[i], all point[j] with j < i have x <= x[i]
    points.sort((a, b) => {
        if (a[0] === b[0]) return b[1] - a[1]; // If x is equal, sort by y descending
        return a[0] - b[0]; // Otherwise, sort by x ascending
    });

    // Step 2: Iterate through each point[i] as potenti

HydroOpt

# HydroOpt: Deep Learning and Optimization for Water Resource Management **HydroOpt** is a research-oriented framework that integrates **time series forecasting** and **resource allocation optimization** to tackle challenges in water resource management. It combines modern **deep learning models** (LSTM, CNN, Transformer, HydroCortex) with **convex optimization** and the **Adaptive Intertemporal Allocation (AIA)** strategy to enable robust planning under uncertainty. This repository provides a complete, modular codebase with preprocessing, modeling, optimization, evaluation, and visualization components. It is designed for **reproducibility**, **scalable experiments**, and **practical deployment**. --- ## ✨ Key Highlights - **Forecasting Models** - LSTM, CNN, Transformer for temporal prediction - HydroCortex: graph-based spatiotemporal learning framework - **Optimization Framework** - Convex allocation solver with demand, capacity, and ecological constraints - Adaptive Intertemporal Allocation (AIA) for multi-period planning - **Feature Engineering** - Seasonal, lagged, and rolling statistics - **Evaluation** - MAE, RMSE, MAPE, R² metrics - **Visualization** - Time series plots, allocation heatmaps - **Testing** - Extensive `pytest` suite for models, optimization, and utilities --- ## 📂 Repository Structure HydroOpt/ │── README.md │── LICENSE │── requirements.txt │── setup.py │ ├── data/ # Example or linked datasets │ ├── README.md │ └── samples/ │ ├── src/ # Core modules (15 Python files) │ ├── init.py │ ├── preprocessing.py │ ├── feature_engineering.py │ ├── model_lstm.py │ ├── model_cnn.py │ ├── model_transformer.py │ ├── model_hydrocortex.py │ ├── optimization_core.py │ ├── optimization_aia.py │ ├── evaluation.py │ ├── visualization.py │ ├── utils.py │ ├── config.py │ ├── train.py │ └── run_experiment.py │ ├── experiments/ # Configs & results │ ├── configs/ │ └── results/ │ └── tests/ # Unit tests (pytest) ├── test_models.py ├── test_optimization.py └── test_utils.py --- ## ⚙️ Installation Clone the repository and set up the environment: ```bash git clone https://github.com/yourusername/HydroOpt.git cd HydroOpt pip install -r requirements.txt Requirements Key dependencies include: torch ≥ 2.0 scikit-learn cvxpy xarray, netCDF4 (for climate/hydrology data) matplotlib, seaborn, plotly Full list: see requirements.txt.
# Core scientific stack
numpy>=1.24.0
pandas>=2.0.0
scipy>=1.11.0

# Deep learning framework
torch>=2.0.0
torchvision>=0.15.0
torchaudio>=2.0.0

# Machine learning & utilities
scikit-learn>=1.3.0
networkx>=3.1
tqdm>=4.65.0

# Optimization
cvxpy>=1.3.2

# Data handling
xarray>=2023.1.0
netCDF4>=1.6.4
pyyaml>=6.0
hydra-core>=1.3.2

# Visualization
matplotlib>=3.7.0
seaborn>=0.12.2
plotly>=5.14.0

# Optional: GPU accelerated optimization (only if CUDA is available)
cup

Epicor BPM - Prevent Deletion

// Check if any QuoteHed row is marked for deletion
var deletedQuote = ds.QuoteHed.FirstOrDefault(r => r.RowMod == "D");

if (deletedQuote != null)
{
    // Throw a business logic exception to prevent deletion
    // This ensures the user cannot delete sales quotes through the UI or service
    throw new BLException("Sales Quote deletion is not allowed.");
}

Hydroponic Smart System

BPVP Samarinda Ini adalah description
#include <WiFi.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <DHT.h>
#include <BlynkSimpleEsp32.h>
#include <NTPClient.h>
#include <WiFiUdp.h>

gistfile1.txt

#include <WiFi.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <DHT.h>
#include <BlynkSimpleEsp32.h>
#include <NTPClient.h>
#include <WiFiUdp.h>

PPAPに変わる方法

# ファイル便サービス+パスワード送信

ファイル便サービスを使ってファイルをアップロードしてURLを発行し、パスワードをメール等で送るのが現時点では一番良さそう。

## ファイル便サービス

ファイル便サービスの比較としては以下の感じ。

| サービス        | 知名度 | セキュリティ機能              | 法人導入実績       | コメント         |
| ----------- | --- | --------------------- | ------------ | ------------ |
| ギガファイル便     | ◎   | パスワード・削除キー            | △(主に個人・中小向け) | 一番「聞きなじみ」あり  |
| firestorage | ○   | パスワード、暗号化、法人向け「セキュア便」 | ○            | 老舗で法人実績あり    |
| データ便        | ○   | SSL暗号化、通知、ログ管理        | ○            | GMO運営の安心感    

Substituição sem escape (RAW)

&P12_CNPJ!RAW.

SSG時のAPIキー管理方法

# SSGでAPIキーを露出させない方法

## 背景
- APIキーはサービスの認証情報であり、フロントエンド側でAPIキーを露出させてしまうと他者が使用できてしまう。
- SSGでレンダリングする場合、APIキーの取り扱いに注意が必要。SSRであれば、サーバーサイドで実行する処理の中でAPIキーを使用したらOK。

---

## Next.jsの環境変数の扱い

- Next.jsでは、環境変数(APIキーなど)は`.env`ファイルに記載する。
- 例:`.env.local`ファイル
  ```
  HOGE_API_KEY=xxxxxxxxxxxxxxxxxxxxx
  ```
- `process.env.HOGE_API_KEY`でサーバーサイドから参照可能。
- クライアント側の処理の中で`process.env`を利用した場合、ビルド時に値が埋め込まれ、誰でも閲覧可能となる。

---

## SSR(サーバーサイドレンダリング)でのAPIキーの扱い
- サーバー側でリクエストを受けて、APIキーを使って外部サービスにアクセスする。
- Next.jsではAPI R

Related post by the single file

$context['related_posts'] = Timber::get_posts([
    'post_type' => 'post',
    'orderby' => 'date',
    'order' => 'DESC',
    'posts_per_page' => 3,
    'post__not_in' => [$context['post']->ID],
]);

SpinServeNet

# Youth Tennis Spin-Serve Modeling (STCM + ACSOP) A compact PyTorch implementation that mirrors the paper’s core ideas for analyzing and optimizing the **spin serve** in young tennis players. It provides: - A **dual-stream encoder** (spatial joints + temporal velocities/accelerations) - A lightweight **STCM head** (Segmental Torque Coordination) to model proximal-to-distal momentum transfer - An **ACSOP knob** (Age-Calibrated Spin Optimization Protocol) to softly enforce age-aware timing and torque limits during training - Simple training/evaluation loops and a minimal example > This repo is a practical starter that follows the formulations and system diagrams described in the paper (STCM, ACSOP, datasets, and experimental configuration). :contentReference[oaicite:0]{index=0} --- ## Why this repo? - **Readable**: Focuses on clarity over cleverness; no heavy custom CUDA or obscure layers. - **Modular**: Swap encoders or the loss without touching the data pipeline. - **Faithful**: Implements key ingredients shown in the figures and formulas (e.g., dual-branch encoders, cross-fusion, torque/timing penalties, spin-efficiency proxy). --- ## File structure . ├─ model.py # The model (Dual-stream Transformer + STCM/ACSOP heads) ├─ README.md # You are here └─ (optional) your_train_script.py --- ## Data format (expected by `model.py`) Pass a dictionary to the model with: - `batch["joints"]`: shape `(B, T, J, 3)` — 3D joint coordinates in meters. - `batch["vel"]`: shape `(B, T, J, 3)` — joint velocities (m/s). *Tip:* If you only have positions, you can finite-difference to get velocities. Optional metadata (if available): - `batch["age"]`: shape `(B,)` — age in years (float or int). Used by ACSOP scaling. - `batch["mask"]`: shape `(B, T)` — 1 for valid frames, 0 for padding. The model outputs a dictionary with: - `out["spin_pred"]`: `(B,)` — predicted spin (arbitrary units; you set the scale). - `out["aux"]`: dict with intermediate features (e.g., timing/torque proxies) to build custom losses. --- ## Quick start ```python import torch from model import STCMACSOPModel, STCMACSOPConfig cfg = STCMACSOPConfig( num_joints=25, # set to your skeleton hidden_dim=256, transformer_layers=4, transformer_heads=8, dropout=0.1, ) model = STCMACSOPModel(cfg) B, T, J = 8, 60, cfg.num_joints batch = { "joints": torch.randn(B, T, J, 3), "vel": torch.randn(B, T, J, 3), "age": torch.full((B,), 14.0) # example: 14 years old } out = model(batch) print(out["spin_pred"].shape) # -> torch.Size([8])

```python
# model.py
# A compact PyTorch model inspired by STCM (Segmental Torque Coordination Model)
# and ACSOP (Age-Calibrated Spin Optimization Protocol).
# Implements:
#   - Dual-stream Transformer encoders (spatial joints & temporal velocities)
#   - Cross-fusion
#   - Proximal->distal coordination proxies
#   - Age-aware timing/torque constraints as soft penalties

from dataclasses import dataclass
from typing import Dict, Optional

import torch
import torch.nn as nn
impo

PulseML: A Lightweight Residual MLP Framework

# PulseML: A Lightweight Residual MLP Framework PulseML is a flexible PyTorch-based model framework designed to accelerate rapid prototyping, baseline creation, and production deployment of machine learning systems. It provides a **residual MLP architecture** that can seamlessly handle both **vector inputs** (e.g., tabular data) and **temporal sequences** (e.g., time-series, logs). The design philosophy behind PulseML is: - **Clarity**: Readable, typed, well-documented code. - **Simplicity**: A single file (`model.py`) you can drop into any project. - **Flexibility**: Supports classification and regression tasks, with extendable modules. - **Production readiness**: Save, load, and predict with minimal effort. --- ## ✨ Features - 🔹 **Residual MLP backbone** with GELU activation - 🔹 **Configurable hidden dimensions** and dropout - 🔹 Optional **BatchNorm** for stable training - 🔹 Handles both `(B, D)` vectors and `(B, T, D)` temporal sequences - 🔹 **Temporal pooling modes**: `mean`, `max`, `last` - 🔹 Easy **save/load API** for deployment - 🔹 **Classification + regression** support --- ## 📂 Project Structure

```python
from __future__ import annotations

from dataclasses import dataclass
from typing import Iterable, List, Literal, Optional, Tuple, Union

import torch
import torch.nn as nn
import torch.nn.functional as F


TensorLike = Union[torch.Tensor]


def _init_weights(m: nn.Module) -> None:
    """Xavier init for Linear layers; set BatchNorm defaults."""
    if isinstance(m, nn.Linear):
        nn.init.xavier_uniform_(m.weight)
        if m.bias is not None:
            nn.

BioKineShotNet

# BioKineShotNet: NeuroKinematic Alignment for Elite Basketball Jump Shot Analysis This repository provides a clean PyTorch reference implementation of **BioKineShotNet** with **NeuroKinematic Alignment** for modeling jump-shot biomechanics from spatiotemporal joint trajectories and optional multimodal inputs. The model combines graph-based motion encoders, recurrent temporal dynamics, anthropometric conditioning, and domain-driven regularizers to make **physiologically plausible**, **personalized**, and **interpretable** predictions of shot success and release parameters. :contentReference[oaicite:0]{index=0} > TL;DR: Feed sequences of joint angles/velocities (and optional cues) into a ST-GCN + GRU. Train with classification + biomechanical regularizers. Decode release parameters and align latent codes to a biomechanical manifold while encouraging subject-specific but generalizable embeddings. --- ## Highlights - **Spatiotemporal Graph Encoder (ST-GCN):** preserves anatomical connectivity. - **Temporal GRU + Attention:** captures short- and long-range coordination around release time. - **Anthropometric Conditioning:** player embeddings via conditional normalization. - **Physiology-Aware Losses:** - Smooth dynamics & energy regularization - Release-parameter reconstruction - Biomechanical-manifold projection penalty - Synergy-aligned torque decomposition - Visuo-motor causal consistency - Temporal focus near release - Metric contrastive loss across athletes --- ## Repository Structure

```python
# model.py
# BioKineShotNet + NeuroKinematic Alignment (PyTorch reference)
# MIT License

from typing import Optional, Dict, Any
import math
import torch
import torch.nn as nn
import torch.nn.functional as F


# ---------------------------
# Utility: Graph Convolution
# ---------------------------

class GCNLayer(nn.Module):
    """
    Simple first-order GCN layer: H' = A_norm @ H @ W + b
    Expects A to be (N,N); inputs H: (B,T,N,C)
    """
    def __init__(se

SmartTrain-BCPE

# BCPE-AKRS: A Minimal PyTorch Reference A concise PyTorch reference implementation of the **Bio-Conditioned Performance Estimator (BCPE)** with a lightweight **Adaptive Kinetic Regulation Strategy (AKRS)** policy head for smart sports training scenarios. This repo focuses on clarity and hackability: clean modules, typed signatures, and end-to-end examples with synthetic data. > **What it is**: a practical starting point that mirrors the architecture described in the source paper—multimodal encoders → attention fusion → temporal modeling (GRU + multi-scale 1D conv) → FiLM bio-conditioning → stochastic latent (μ, Σ) → decoder; plus a tiny AKRS policy with fatigue-aware gating. > **What it is not**: a drop-in reproduction with datasets, training loops, or SOTA numbers. --- ## Features - **Multimodal encoders** for vision/pose, IMU, EMG, and context streams. - **Attention fusion** across modalities. - **Temporal modeling** via GRU + multi-scale temporal convolutions. - **FiLM conditioning** from a transformer-style history embed (bio-condition). - **Stochastic latent head** (μ, logσ²) + reparameterization. - **Sequential decoder** with previous-step feedback option. - **AKRS policy (toy)**: safe action bounds, fatigue-aware intensity, and fallback gating. --- ## Quickstart ### 1) Install ```bash pip install torch --index-url https://download.pytorch.org/whl/cpu # or your CUDA build of PyTorch

```python
# model.py
# A minimal, hackable reference for BCPE + a tiny AKRS policy head.
# - Python 3.9+
# - PyTorch 2.0+
from __future__ import annotations
from typing import Dict, Tuple, Optional
import torch
import torch.nn as nn
import torch.nn.functional as F


# ----------------------------
# Utility Blocks
# ----------------------------

class MLP(nn.Module):
    def __init__(self, in_dim: int, hidden: int, out_dim: int, dropout: float = 0.0):
        super().__init__(