550 free technology calculators and tools. Solve real-world technology problems instantly with accurate, step-by-step results on ApexCalc.
Calculate password entropy in bits based on character set size and length. Determine strength against brute force and dictionary attacks.
Estimate time to brute force crack a password given hash type, GPU count, and password character set. Compare bcrypt, SHA-256, MD5 crack rates.
Calculate bcrypt hash time per login based on cost factor. Find the optimal cost factor that maximizes security while keeping login latency under 300ms.
Configure Argon2 memory cost, iteration count, and parallelism for optimal password security. Balance server memory usage against cracking resistance.
Calculate TOTP time window validity accounting for clock drift. Determine acceptable window size to balance usability against replay attack risk.
Calculate the security risk of different JWT expiry times. Balance user experience against stolen token exposure window and refresh token security.
Calculate OAuth 2.0 PKCE code verifier entropy to prevent authorization code interception attacks. Verify compliance with RFC 7636 requirements.
Evaluate SSL/TLS key sizes for current and future security. Compare RSA 2048/4096, ECDSA P-256/P-384, and Ed25519 security equivalences.
Calculate TLS handshake latency overhead for TLS 1.2 vs TLS 1.3. Model round-trip impact on first connection latency and resumption speed.
Calculate certificate transparency log propagation delay and determine detection window for misissued certificates. Plan CT monitoring response times.
Calculate DNSSEC DNS query overhead in latency and packet size. Evaluate trade-off between DNS spoofing protection and increased query costs.
Calculate firewall rule set complexity score. Identify shadow rules, redundant rules, and conflicting policies that increase attack surface.
Calculate IDS/IPS alert false positive rate and measure analyst alert fatigue impact. Optimize signature thresholds to improve SOC efficiency.
Calculate SOC analyst SIEM alert fatigue index from daily alert volume, false positive rate, and mean investigation time. Model analyst capacity and missed threat probability.
Calculate penetration test coverage score across OWASP Top 10, network, application, and social engineering vectors. Identify testing gaps by risk tier.
Calculate contextualized CVE risk score by adjusting CVSS base score for exploitability, remediation availability, and environment-specific factors.
Calculate patch compliance rate across your server fleet. Measure mean time to patch critical CVEs and exposure window against active exploitation.
Estimate your organization exposure window for zero-day vulnerabilities based on threat intelligence freshness, detection capability, and patch deployment speed.
Model phishing click rate reduction from security awareness training frequency. Calculate ROI of training investment against breach cost reduction.
Estimate social engineering attack success probability based on employee training level, verification controls, and target specificity (spear phishing vs generic).
Estimate mean time to detect insider threats based on UEBA alerting, data access monitoring, and DLP controls. Quantify data exposure before detection.
Calculate maximum data exfiltration volume at various upload bandwidth throttle settings. Determine DLP thresholds to detect bulk data theft in progress.
Assess likelihood of data loss prevention bypass based on DLP coverage gaps, encryption blind spots, and sanctioned cloud application leakage.
Calculate optimal encryption key rotation interval based on data sensitivity, encryption algorithm strength, and breach detection capability.
Compare AES-256-GCM and ChaCha20-Poly1305 encryption throughput on hardware with and without AES-NI acceleration. Choose the right cipher for your deployment.
Compare RSA and elliptic curve (ECDSA/EdDSA) key sizes for equivalent security levels. Calculate certificate size and handshake speed differences.
Estimate post-quantum cryptography migration urgency based on data sensitivity and harvest-now-decrypt-later attack risk window.
Calculate VPN protocol bandwidth overhead from encapsulation headers and encryption. Compare IPSec, OpenVPN, WireGuard, and SSL VPN efficiency.
Calculate blast radius reduction from network segmentation. Model how VLAN isolation and microsegmentation limit lateral movement after initial compromise.
Estimate microsegmentation policy count and management complexity for your workload count. Calculate tooling and operational overhead.
Calculate CPU and throughput overhead of encrypting east-west (inter-service) traffic with mTLS. Assess service mesh encryption impact on microservices performance.
Calculate SD-WAN path selection efficiency compared to traditional MPLS. Model cost savings from internet breakout and application-aware routing.
Estimate BGP convergence time after route withdrawal for different network topologies. Model impact on traffic during routing protocol failover.
Calculate latency improvement from deploying anycast routing to route users to the nearest PoP. Model P99 latency reduction across geographic regions.
Calculate CDN DDoS absorption capacity vs your origin bandwidth. Determine whether CDN DDoS protection is sufficient for your threat profile.
Calculate WAF request analysis cost and false positive impact at scale. Compare managed WAF vs self-hosted ModSecurity for high-traffic applications.
Calculate probability of detecting botnet command and control communication based on DNS monitoring, traffic analysis, and threat intelligence coverage.
Calculate honeypot detection effectiveness based on placement, fidelity, and attacker sophistication. Estimate time to detection for internal lateral movement.
Calculate threat intelligence feed freshness score based on indicator age distribution and feed update frequency. Measure stale IOC impact on detection.
Estimate security incident containment time from initial detection to isolation. Calculate data exposure volume during containment delay.
Score digital forensics evidence integrity based on chain of custody completeness, write blocker usage, and hash verification coverage.
Calculate Security Operations Center analyst capacity based on alert volume, investigation time, and shift coverage. Determine staffing to meet SLA targets.
Calculate red team exercise coverage score against MITRE ATT&CK framework. Identify detection gap percentage by tactic and technique.
Calculate purple team exercise effectiveness score. Measure detection rate improvement and mean time to detect reduction achieved through joint red/blue exercises.
Calculate compliance automation coverage ratio across SOC 2, PCI DSS, HIPAA, and ISO 27001 controls. Estimate audit preparation time reduction from automation.
Calculate GDPR Data Subject Request (DSR) fulfillment time and cost. Assess risk of exceeding 30-day deadline based on data system complexity.
Calculate HIPAA breach notification deadlines and financial risk from delayed reporting. Model notification scope and media notice thresholds.
Calculate PCI DSS cardholder data environment (CDE) scope complexity and compliance cost. Estimate QSA assessment cost and control implementation effort.
Assess zero trust security maturity across identity, device, network, application, and data pillars. Score against CISA Zero Trust Maturity Model tiers.
Estimate SQL query execution cost from row counts, index usage, and join complexity. Identify slow queries before they hit production.
Calculate data warehouse storage, compute, and cost sizing for Snowflake, BigQuery, and Redshift. Model query concurrency and compression ratios.
Calculate ETL pipeline throughput in rows per hour based on source read rate, transformation cost, and target write throughput. Identify ETL bottlenecks.
Calculate Apache Spark executor memory configuration from data size, shuffle partition count, and GC overhead. Prevent out-of-memory errors and disk spill.
Calculate the optimal number of Kafka partitions for target throughput. Balance parallelism, consumer group scaling, and partition overhead.
Compare total cost of data lake (S3 + Athena) vs data warehouse (Snowflake/Redshift) for different query patterns and data volumes.
Calculate BI dashboard query concurrency requirements from user count and refresh rates. Size warehouse compute for peak dashboard load.
Calculate OLAP pre-aggregation speedup versus ad-hoc query. Model rollup cube size vs query latency trade-off for different aggregation levels.
Compare columnar and row-based storage compression ratios for analytics workloads. Calculate storage savings and I/O reduction from columnar format.
Calculate composite data quality score from completeness, accuracy, consistency, timeliness, and uniqueness dimensions. Prioritize data cleaning efforts by impact.
Estimate duplicate record detection rate from fuzzy matching threshold and blocking strategy. Calculate precision-recall trade-off for entity resolution.
Calculate data lineage complexity from pipeline depth, branching factor, and system count. Estimate impact analysis time for schema change propagation.
Estimate machine learning feature engineering time based on raw feature count, data quality issues, and domain complexity. Plan ML project timelines accurately.
Calculate machine learning model training compute cost from dataset size, model complexity, and GPU/TPU type. Estimate training time and cloud cost.
Model the relationship between training data size and ML model accuracy using power law scaling. Estimate data collection ROI at different accuracy targets.
Calculate cross-validation score variance and confidence intervals. Determine whether model performance differences are statistically significant.
Calculate hyperparameter search space size and required compute budget. Compare grid search, random search, and Bayesian optimization efficiency.
Calculate AutoML platform iteration cost from dataset size, algorithm count, and trial budget. Compare AutoML ROI vs manual tuning engineer time.
Estimate machine learning model inference latency from model size, framework overhead, and hardware. Compare batch vs real-time inference cost and latency.
Calculate minimum detectable effect (MDE) for A/B tests given sample size, significance level, and power. Determine test duration for your traffic levels.
Calculate required sample size for desired statistical power given effect size, alpha level, and test type. Supports t-tests, proportions, and ANOVA.
Calculate chi-square test statistic for goodness of fit and independence tests. Determine whether observed distributions differ significantly from expected.
Calculate Cohen d effect size for t-tests. Interpret practical significance beyond statistical significance for business decision-making.
Calculate one-way ANOVA F-statistic to test whether group means differ significantly. Determine whether to proceed with post-hoc pairwise comparisons.
Calculate R-squared and adjusted R-squared for regression models. Assess model fit quality and penalize for unnecessary predictors.
Calculate Variance Inflation Factor (VIF) to detect multicollinearity in regression models. Determine which predictors to remove or combine.
Detect heteroscedasticity in regression residuals using Breusch-Pagan and White tests. Determine whether to use robust standard errors.
Select optimal ARIMA (p,d,q) order using AIC and BIC criteria. Compare information criteria across model orders for time series forecasting.
Decompose time series into trend, seasonal, and residual components using STL or classical decomposition. Measure seasonality strength and trend stability.
Calculate anomaly detection z-score thresholds for time series. Balance false positive rate against detection sensitivity for operational metrics.
Calculate cohort retention rates at D1, D7, D14, and D30. Benchmark against industry standards by app category and identify retention improvement levers.
Calculate conversion funnel drop-off rates by step. Identify the highest-impact optimization point using revenue per visitor analysis.
Compare last-touch, first-touch, linear, time-decay, and data-driven attribution models. Calculate channel budget allocation differences across attribution approaches.
Calculate predicted Customer Lifetime Value using average order value, purchase frequency, and customer lifespan. Model CLV by cohort and segment for acquisition optimization.
Calculate customer churn probability from engagement signals and subscription health scores. Determine intervention threshold for proactive retention campaigns.
Calculate the revenue impact correlation of Net Promoter Score changes. Model growth from promoter referrals and churn reduction from detractor remediation.
Estimate product analytics event volume from MAU, sessions per user, and events per session. Calculate storage and cost for Amplitude, Mixpanel, or Segment.
Calculate clickstream data storage costs in S3, BigQuery, or Snowflake. Model compression ratios and query cost for different retention periods.
Calculate recommendation system Precision@K and NDCG metrics. Compare collaborative filtering, content-based, and hybrid recommendation approaches.
Calculate NDCG (Normalized Discounted Cumulative Gain) for search engine quality evaluation. Compare relevance ranking across different search approaches.
Calculate knowledge graph entity resolution precision and recall. Estimate graph construction cost from entity count, relation density, and resolution accuracy.
Estimate graph database traversal cost for path finding queries. Model Neo4j traversal performance by hop count, node degree, and index coverage.
Calculate end-to-end streaming analytics latency from event capture to dashboard update. Model Kafka, Flink/Spark Streaming, and sink latency components.
Calculate optimal dashboard refresh rate to balance data freshness against database query load and user experience.
Estimate data mesh domain infrastructure cost per domain team. Calculate total platform cost versus centralized data warehouse for organizations of different sizes.
Calculate data catalog coverage score across critical datasets. Measure metadata completeness, lineage documentation, and data ownership coverage.
Calculate differential privacy epsilon and noise level for privacy-preserving analytics. Balance privacy budget against statistical utility of query results.
Evaluate synthetic data quality using statistical fidelity, ML utility, and privacy metrics. Determine whether synthetic data is a suitable replacement for real data.
Calculate data product pricing for marketplace listing based on data freshness, exclusivity, coverage, and buyer ROI. Model subscription vs consumption pricing.
Calculate business intelligence investment ROI from improved decision speed, cost savings, and revenue lift. Justify BI platform investment with quantified outcomes.
Quantify demographic parity difference, equalized odds, and disparate impact ratio to audit ML model fairness across protected groups.
Calculate the expected cost of classification errors given FP/FN rates and per-error costs to find the optimal decision threshold.
Compute precision and recall at a given classification threshold and find the F-beta optimal point on the precision-recall curve.
Interpret ROC AUC scores, compute confidence intervals via DeLong method, and compare two classifiers statistically.
Demonstrate why accuracy misleads on imbalanced datasets and compute F1, balanced accuracy, and Matthews correlation coefficient.
Estimate local interpretable model-agnostic feature weights around a prediction instance using LIME perturbation sampling.
Compute Shapley value feature contributions for a prediction using the SHAP framework to explain model outputs fairly across all features.
Calculate the maximum L-infinity or L2 perturbation budget for adversarial examples that remain imperceptible given pixel depth and image size.
Measure covariate shift severity using Maximum Mean Discrepancy or KL divergence between training and deployment distributions.
Estimate total communication rounds and bandwidth needed for federated model training given model size, client count, and compression ratio.
Compute epsilon and delta privacy budget consumption for Gaussian and Laplace mechanisms, and track budget across multiple queries.
Calculate equivalence class sizes, suppression rate, and information loss for a k-anonymized dataset given quasi-identifier combinations.
Verify l-diversity of a dataset by checking each equivalence class contains at least l well-represented distinct sensitive attribute values.
Measure t-closeness by computing the Earth Mover Distance between sensitive attribute distribution in an equivalence class and the overall table.
Estimate the poisoning rate threshold at which a model's accuracy degrades significantly and compute influence function scores for suspicious samples.
Calculate the bit error rate of a watermark embedded in a neural network and estimate the probability of false ownership claims.
Estimate total GPU memory required for a neural network given parameter count, batch size, activation memory, and optimizer state.
Compute FLOPs, memory, and time complexity of multi-head self-attention as a function of sequence length, model dimension, and number of heads.
Estimate BERT inference latency per token given hardware FLOPs, model layers, sequence length, and batch size.
Calculate token-per-second generation throughput for autoregressive models given KV cache size, memory bandwidth, and hardware specifications.
Determine the optimal cosine similarity threshold for semantic similarity tasks by computing precision-recall at each threshold on a labeled dataset.
Compute Recall@K and Mean Reciprocal Rank (MRR) for a semantic search system to evaluate retrieval quality across query sets.
Balance intra-list diversity (ILD) against recommendation accuracy using diversity-accuracy tradeoff curves for collaborative filtering systems.
Compute cumulative regret bound for online gradient descent and follow-the-leader algorithms over T rounds given learning rate and loss structure.
Compare UCB1, Thompson Sampling, and epsilon-greedy exploration strategies and compute expected regret given arm reward distributions.
Estimate environment interactions needed to reach target performance for model-free vs model-based RL algorithms given state-action space size.
Estimate Q-learning convergence time to epsilon-optimal policy given state-action count, discount factor, and learning rate schedule.
Compute variance reduction from baseline subtraction, reward normalization, and advantage estimation in REINFORCE and PPO policy gradient methods.
Compute TD error, GAE (Generalized Advantage Estimation), and n-step returns for actor-critic methods given value function estimates.
Compute intrinsic reward bonus from prediction error of a forward dynamics model to encourage exploration in sparse reward environments.
Design a training difficulty schedule from easy to hard examples and estimate convergence speedup over random sampling given task difficulty distribution.
Estimate optimal number of fine-tuning epochs and learning rate for transfer learning given source-target domain similarity and dataset size.
Quantify domain shift between source and target using A-distance, H-divergence, and proxy A-distance for domain adaptation gap estimation.
Estimate zero-shot generalization error bound given semantic embedding quality, class attribute overlap, and bias-variance decomposition.
Estimate expected accuracy for N-way K-shot classification tasks using prototypical network and matching network theoretical bounds.
Calculate optimal inner loop gradient steps and outer loop meta-learning rate for MAML and Reptile meta-learning algorithms.
Estimate total GPU-hours for neural architecture search given search space size, early stopping efficiency, and progressive search strategies.
Estimate the expected best pipeline performance for AutoML given budget (time/evaluations), search space size, and Bayesian optimization warm-start.
Calculate feature staleness impact on model accuracy and determine optimal feature refresh interval given decay rate and compute cost.
Apply Page-Hinkley test, ADWIN, or Kolmogorov-Smirnov test to detect concept drift and covariate drift in production model streams.
Calculate minimum shadow traffic percentage needed to detect a performance difference of delta within T days given daily request volume.
Compute statistical significance of champion vs challenger model performance difference using paired t-test, Wilcoxon, or bootstrap methods.
Estimate total storage cost for model versioning registry given model size, number of experiments, and retention policy with incremental delta storage.
Estimate compute and storage overhead from MLflow experiment tracking given logging frequency, metric count, and artifact size.
Measure feature importance stability using Spearman rank correlation and coefficient of variation across cross-validation folds.
Verify stratified k-fold cross-validation maintains class balance across folds and compute expected variance reduction from stratification.
Quantify ensemble diversity using pairwise error correlation, ambiguity decomposition, and Q-statistic to estimate ensemble error reduction.
Compare bias and variance reduction from bagging (variance reducer) vs boosting (bias reducer) given base learner characteristics.
Compute optimal gradient boosting learning rate, number of trees, and max depth given bias-variance tradeoff and early stopping rounds.
Compute optimal L1/L2 regularization strength using validation curve, bias-variance tradeoff analysis, and cross-validated score.
Estimate accuracy impact of dropout regularization at different rates and find the optimal dropout schedule for preventing co-adaptation in neural networks.
Calculate daily and monthly Bitcoin mining profit after electricity costs given hashrate, power consumption, electricity rate, and current difficulty.
Convert hashrate (TH/s, EH/s) to expected daily BTC earnings based on network difficulty and current block reward.
Predict the next Bitcoin difficulty adjustment percentage given current block times and blocks remaining in the epoch.
Estimate kWh energy consumed per Bitcoin transaction based on total network hashrate, miner efficiency, and daily transaction throughput.
Calculate annualized ROI for Ethereum, Cardano, or Solana validator staking given network participation rate and validator rewards.
Compute annualized staking yield accounting for compounding frequency, validator commission, slashing risk discount, and token inflation dilution.
Calculate impermanent loss percentage when providing liquidity to an AMM pool given initial and current price ratio of the token pair.
Calculate price impact and slippage for a trade against a constant product (x*y=k) AMM pool given input amount and pool reserves.
Calculate annualized fee APY for liquidity provision given 24h trading volume, total pool TVL, and fee tier.
Compute total yield farming APY combining trading fees, liquidity mining rewards, and auto-compounding frequency for DeFi strategies.
Analyze DeFi protocol sustainability by computing yield-to-TVL ratio and annualized revenue to identify unsustainable token emission-funded yields.
Convert Ethereum gas fees from gwei to USD given gas limit, base fee, priority tip, and ETH price.
Compare transaction cost on Ethereum mainnet vs Layer 2 rollups (Arbitrum, Optimism, Base) and compute percentage savings per transaction type.
Estimate calldata compression ratio for optimistic and ZK rollups and compute cost savings from EIP-4844 blob transactions.
Compare fees and transfer time for cross-chain bridge protocols given source and destination chains, asset type, and transfer amount.
Estimate MEV opportunity from arbitrage, liquidation, and sandwich attack scenarios given pending transaction parameters and pool state.
Calculate minimum price discrepancy needed to profit from a flash loan arbitrage after fees, gas costs, and slippage.
Estimate smart contract security audit cost based on lines of code, complexity score, external integrations, and upgrade patterns.
Calculate minimum token participation needed to pass a DAO proposal given quorum requirements, voter turnout history, and token distribution.
Calculate governance power dilution from new token issuance proposals and estimate voting power percentage before and after dilution.
Calculate present value of perpetual NFT royalty stream given current floor price, trading volume, royalty rate, discount rate, and volume decay.
Analyze NFT collection health by computing floor price-to-volume ratio, average sale price premium, and holder concentration metrics.
Model token unlock schedule and estimate sell pressure as percentage of daily trading volume for each vesting cliff and linear unlock.
Analyze token supply metrics including fully diluted valuation, circulating supply ratio, and implied future dilution from remaining token emissions.
Calculate annual inflation rate from token emission schedule and estimate real yield after accounting for dilution from new issuance.
Estimate the implied discount in current token price relative to FDV price and compute breakeven price under various unlock scenarios.
Calculate Bitcoin NVT ratio (market cap / on-chain transaction volume) as a valuation metric analogous to P/E ratio for equities.
Compute Bitcoin stock-to-flow ratio and cross-asset model price estimate based on current supply and annual issuance post-halving.
Calculate MVRV ratio (Market Value to Realized Value) to identify Bitcoin market top and bottom signals based on profit/loss of all holders.
Calculate SOPR (ratio of coin sale price to acquisition price) to measure aggregate profit/loss realization and identify market sentiment shifts.
Compute Bitcoin realized capitalization and compare to market cap to derive MVRV ratio and assess aggregate holder profit/loss distribution.
Calculate kWh energy consumed per Bitcoin transaction and compare to other payment systems and PoS blockchains.
Estimate CO2 emissions from crypto mining operations and calculate carbon offset cost to achieve net-zero mining given energy mix and emission factors.
Calculate liquidation price for leveraged DeFi positions on Aave, Compound, or MakerDAO given collateral ratio, LTV, and health factor.
Annualize perpetual futures funding rate and compute cost of carry for long vs short positions given current funding interval and rate.
Calculate implied volatility from crypto options prices using Black-Scholes inversion and compare to realized volatility for vol premium analysis.
Verify put-call parity for crypto options and identify arbitrage opportunities when parity is violated given calls, puts, spot, and risk-free rate.
Calculate delta hedge ratio for crypto option positions and estimate daily rebalancing cost given gamma, volatility, and underlying price movement.
Compute rolling correlation matrix for a crypto portfolio and identify diversification benefits given historical return correlations.
Calculate annualized Sharpe ratio for a crypto trading strategy given daily returns, risk-free rate, and sample period.
Calculate Sortino ratio using downside deviation instead of total volatility to better evaluate strategies with asymmetric return distributions.
Calculate maximum drawdown, drawdown duration, and recovery time for crypto assets and strategies from historical price series.
Calculate 1-day and 10-day Value at Risk at 95% and 99% confidence for crypto portfolios using historical simulation and parametric methods.
Calculate Conditional Value at Risk (CVaR) / Expected Shortfall for crypto portfolios, measuring the expected loss beyond the VaR threshold.
Calculate blockchain transaction fee revenue per day, compare to block subsidy, and project fee-only security budget post-halving.
Calculate current percentage of miner revenue from transaction fees versus block subsidy and track post-halving fee dependence trend.
Calculate Lightning Network payment routing fee given base fee, fee rate, payment amount, and number of hops.
Compare transaction size overhead for Monero (RingCT), Zcash (zk-SNARKs), and MimbleWimble vs transparent Bitcoin transactions.
Score stablecoin peg stability by analyzing historical deviation, reserve backing ratio, and redemption mechanism type.
Calculate the adoption rate of internal golden path templates across engineering teams. Measures what percentage of new services use the approved scaffolding vs custom setups, indicating platform engineering effectiveness.
Model the correlation between Internal Developer Portal NPS scores and engineering productivity metrics. Quantify the productivity delta between promoter and detractor developer cohorts using DORA metrics as proxies.
Calculate the optimal token bucket size and refill rate for API gateway rate limiting. Balance burst capacity against sustained throughput limits to protect backend services while allowing legitimate traffic spikes.
Quantify the CPU overhead introduced by service mesh sidecar proxies (Envoy, Linkerd) relative to application container CPU usage. Calculate the fleet-wide cost of mesh adoption and break-even point vs. unmanaged networking.
Calculate the per-syscall and per-packet overhead introduced by eBPF observability programs in microseconds. Compare eBPF-based tracing (Cilium, Pixie, Tetragon) against traditional agent-based approaches for production suitability.
Optimize distributed tracing sampling rates to balance observability coverage against storage and ingestion costs. Calculate the minimum sampling rate needed to catch a given percentage of errors and latency tail events.
Calculate total log aggregation costs per GB ingested per month across collection, storage, indexing, and query layers. Compare Datadog Logs, Elastic, Loki, and self-managed solutions for cost optimization.
Quantify the storage and query cost impact of high-cardinality metrics in time-series databases (Prometheus, Datadog, InfluxDB). Calculate the series count explosion from unbounded label dimensions and its financial impact.
Calculate the signal-to-noise improvement from alert correlation and grouping rules. Measure how alert deduplication, dependency-aware suppression, and time-window grouping reduce actionable alert volume and on-call toil.
Calculate on-call engineer burnout risk score based on pager volume, time-of-night incidents, acknowledgement-to-resolution times, and rotation size. Use the score to right-size rotations and set sustainable on-call policies.
Calculate SLA compliance rates for incident response across P1-P4 severity levels. Model time-to-acknowledge, time-to-resolve, and breach penalties. Compare actual response times against contractual SLA commitments.
Track and calculate postmortem action item completion rates to measure reliability program effectiveness. Correlate action item closure with incident recurrence rates to prove postmortem ROI.
Calculate the blast radius of chaos engineering experiments before execution. Quantify the maximum percentage of users, transactions, or revenue at risk from a given fault injection to ensure safe experiment boundaries.
Measure and analyze recovery time metrics from game day exercises. Track MTTR improvements across repeated game day exercises to quantify team preparedness and runbook effectiveness.
Compare the total cost of synthetic monitoring (scheduled probes) versus Real User Monitoring (RUM) for a given service. Calculate cost per detected issue, false positive rate, and coverage overlap to optimize monitoring spend.
Calculate the critical path length in a browser resource waterfall to identify the bottleneck resources blocking page load. Optimize render-blocking scripts, fonts, and stylesheets to minimize time-to-interactive.
Calculate the latency savings from executing logic at the edge (Cloudflare Workers, Vercel Edge, Lambda@Edge) versus roundtripping to origin. Account for cold start overhead, edge compute time, and geographic distribution.
Compare WebAssembly module startup time and execution performance against native code. Calculate the break-even request count where WASM JIT compilation overhead is amortized and steady-state execution benefits dominate.
Calculate PWA install prompt conversion rates and model the engagement uplift from installed vs browser PWA users. Quantify the ROI of PWA investment through retention, session frequency, and push notification opt-in improvements.
Calculate cache hit rates for different service worker caching strategies (Cache First, Network First, Stale While Revalidate). Model the performance vs freshness tradeoff and estimate bandwidth savings from offline-first architectures.
Optimize HTTP cache TTL values to maximize cache hit ratio while controlling content staleness risk. Model the hit rate improvement from TTL increases against the probability of serving stale content during deployment windows.
Calculate the page load improvement from DNS prefetch and preconnect hints for third-party domains. Model the latency savings based on DNS resolution time, TCP handshake, and TLS negotiation for each third-party origin.
Calculate the latency and throughput benefit from TCP connection reuse via HTTP keep-alive versus per-request connection establishment. Model the break-even request count where keep-alive overhead is recovered.
Calculate TLS session resumption rates and the latency savings from TLS 1.3 session tickets versus full handshakes. Model the server CPU cost reduction from higher resumption rates on TLS-heavy workloads.
Calculate the connection establishment savings from HTTP/3 QUIC 0-RTT reconnection versus HTTP/2 TCP+TLS for mobile and high-latency scenarios. Model head-of-line blocking elimination benefits for multiplexed streams.
Calculate the expected latency percentiles based on CDN Point-of-Presence (PoP) coverage relative to user geographic distribution. Model the P50, P95, and P99 user latency for different CDN provider PoP counts and locations.
Calculate the latency and availability benefits of anycast routing versus unicast in multi-region deployments. Model automatic failover behavior, DDoS absorption capacity distribution, and BGP convergence times.
Calculate the decision latency and accuracy of geographic load balancing based on DNS TTL, health check frequency, and failover propagation time. Model the user impact window during regional failures with geo-routing.
Calculate the optimal canary deployment traffic split percentage based on error budget, statistical significance requirements, and rollout velocity targets. Model the time-to-detect threshold for error rate regressions at different canary percentages.
Calculate how feature flag rollout percentage consumes error budget over time. Model the risk exposure at each rollout stage and determine the safe rollout velocity that keeps error budget consumption within SLO targets.
Calculate the end-to-end GitOps reconciliation loop duration from git commit to running pod for Kubernetes workloads. Identify bottlenecks across CI pipeline, image build, registry push, ArgoCD sync, and Kubernetes rollout phases.
Calculate the optimal ArgoCD sync wave ordering for Kubernetes resource dependencies. Model the total sync duration for multi-wave deployments and identify wave consolidation opportunities to reduce total deployment time.
Calculate the drift detection rate and time-to-detection for infrastructure state drift using Terraform plan runs. Model the risk exposure window between drift events and detection, and the cost of undetected drift accumulation.
Calculate the compliance coverage percentage of policy-as-code rules across infrastructure and application resources. Track which resource types, environments, and compliance frameworks are covered versus require manual audit.
Calculate optimal cost anomaly detection thresholds to catch runaway spend without generating alert fatigue. Balance sensitivity (catch real anomalies early) against specificity (avoid false positives from normal business seasonality).
Calculate the percentage of cloud spend attributable to specific teams, products, or cost centers through resource tagging. Model the financial impact of untagged resources and set tagging coverage targets for showback/chargeback programs.
Calculate cloud infrastructure unit cost per monthly active user (MAU) as a FinOps efficiency metric. Track unit cost trends over time to separate infrastructure efficiency improvements from business growth effects.
Calculate potential savings from cloud instance rightsizing recommendations. Model the risk of over-rightsizing (performance impact) against the cost of under-rightsizing (waste) using CPU/memory utilization percentile data.
Calculate the break-even period for Reserved Instance (RI) purchases versus on-demand pricing. Account for partial upfront, full upfront, and no-upfront payment options and model the effective discount at different utilization rates.
Compare AWS Savings Plans (Compute, EC2 Instance, SageMaker) against on-demand pricing for different commitment levels and utilization rates. Calculate effective discount and risk of underutilized commitment.
Calculate the total cost of running workloads on spot instances including interruption overhead (checkpoint/restart costs, reprocessing time). Compare spot vs on-demand TCO accounting for interruption frequency and recovery cost.
Calculate total cost comparison between GPU spot instances and reserved instances for ML training and inference workloads. Account for spot interruption overhead on GPU training jobs and checkpoint frequency optimization.
Calculate the compute overhead of checkpointing preemptible batch jobs. Model the optimal checkpoint interval that minimizes total compute time (checkpoint cost + expected rework from interruptions) for different interruption rates.
Calculate bin packing efficiency for batch workload scheduling on heterogeneous instance fleets. Optimize job-to-instance assignment to minimize total instances needed and reduce per-job cost.
Calculate the critical path length of a workflow DAG (Directed Acyclic Graph) to determine minimum workflow completion time. Identify bottleneck tasks and parallelization opportunities in Airflow, Prefect, or Temporal workflows.
Calculate the total latency of fan-out/fan-in pipeline patterns in distributed systems. Model the P99 completion time where total latency is determined by the slowest parallel branch (maximum, not average).
Calculate partition balance metrics for Kafka, Pulsar, and Kinesis event streaming systems. Identify hot partitions, calculate consumer throughput per partition, and determine optimal partition counts for target throughput.
Calculate appropriate consumer group lag alerting thresholds for Kafka and Kinesis streams. Model the acceptable lag in messages and time-based lag that balances alert sensitivity against false positive rate.
Calculate the cost of replaying messages from Dead Letter Queues (DLQ) in SQS, SNS, and Kafka. Account for reprocessing compute cost, duplicate detection overhead, and the operational cost of DLQ monitoring and management.
Calculate the operational cost and risk of schema evolution in event streaming systems using Confluent Schema Registry or AWS Glue Schema Registry. Model compatibility mode choices (BACKWARD, FORWARD, FULL) against consumer migration cost.
Calculate the annualized inflation rate of a cryptocurrency token based on its emission schedule, current circulating supply, and planned minting events. Essential for tokenomics design and investor analysis.
Calculate the dilution ratio between current circulating supply and maximum supply. Shows what percentage of all tokens ever to exist are currently in circulation and the dilution risk for holders.
Compare fully diluted valuation (FDV) against circulating market cap to assess token overvaluation risk. A high FDV-to-market-cap ratio signals significant future supply pressure.
Apply the quantity theory of money (MV=PQ) to cryptocurrency networks. Calculate token velocity, estimate fair value from network transaction volume, and analyze whether a token is overvalued relative to its economic activity.
Calculate the Network Value to Transactions (NVT) ratio for a cryptocurrency, analogous to the P/E ratio for stocks. High NVT signals overvaluation; low NVT suggests undervaluation relative to on-chain activity.
Calculate the MVRV ratio comparing market capitalization to realized capitalization. Values above 3.5 historically signal market tops; values below 1 indicate undervaluation where most holders are at a loss.
Calculate and interpret the Spent Output Profit Ratio (SOPR) which measures whether coins moved on a given day were sold at a profit or loss. SOPR above 1 means sellers are profitable; below 1 means they're selling at a loss.
Calculate the ratio of realized capitalization to market capitalization to assess aggregate holder profit/loss position. This ratio moving toward 1 indicates most coins are near breakeven, a key support/resistance signal.
Analyze the age distribution of Bitcoin UTXOs to understand hodler behavior and market cycle positioning. Young coin dominance signals distribution tops; old coin accumulation signals market bottoms.
Calculate the growth rate of active blockchain addresses over time to measure network adoption. Compare active addresses to historical periods, identify acceleration phases, and assess whether growth is organic or sybil-influenced.
Calculate the expected Bitcoin mining difficulty adjustment based on current hash rate versus the previous epoch's average. Estimate the percentage change at the next adjustment and its impact on block time targeting.
Calculate the hashprice (revenue per petahash per day) for Bitcoin mining operations. Input electricity cost, hardware efficiency, hash rate, and current network metrics to determine daily profitability and break-even analysis.
Compare the variance and expected time-to-block between solo mining and pool mining. Calculate the probability distribution of finding blocks solo versus the steady payout stream from pool participation.
Calculate expected staking yield based on total staked supply, annual issuance rate, validator commission, and slashing risk. Compare real vs nominal yields accounting for token inflation dilution.
Compare the effective APY of liquid staking derivatives (e.g., stETH, rETH) versus native locked staking. Factor in protocol fees, LSD premium/discount to peg, and opportunity cost of using LSDs in DeFi.
Calculate the Price/Sales equivalent for DeFi protocols by comparing Total Value Locked to annualized protocol revenue. Identify overvalued versus undervalued DeFi protocols using this on-chain fundamental metric.
Calculate the price impact of a trade on an AMM (Automated Market Maker) based on pool liquidity depth. Uses the constant product formula (x*y=k) to estimate slippage for any trade size against current reserves.
Optimize concentrated liquidity position ranges for Uniswap V3. Calculate capital efficiency multiplier, fee earnings projection, and breakeven range based on historical volatility and current tick spacing.
Determine the optimal Uniswap V3 fee tier (0.01%, 0.05%, 0.3%, or 1%) for a given trading pair based on historical volatility, trading volume, and competitive landscape. Maximize LP fee income relative to impermanent loss.
Calculate exact impermanent loss for Uniswap V2-style constant product AMM positions. Input entry and current prices to compute IL percentage and compare against fee income to determine net LP profitability.
Calculate the true net APY of a yield farming strategy after accounting for gas costs, compound frequency, token emission APY, and underlying LP fees. Determine minimum capital required for a strategy to be gas-efficient.
Convert Ethereum gas price in GWEI to total transaction cost in USD. Calculate cost for common operations: simple transfers, token swaps, LP interactions, and complex DeFi transactions using standard gas limits.
Calculate the ETH burn rate from EIP-1559 base fee destruction. Estimate annual ETH burned, net issuance after burns, and whether the network is deflationary or inflationary under current transaction conditions.
Compare transaction costs across Ethereum Layer 2 networks (Arbitrum, Optimism, Base, zkSync) versus Ethereum mainnet. Calculate savings per transaction and breakeven analysis for bridge costs.
Calculate the computational cost of ZK proof generation per transaction in ZK-rollup systems. Estimate proving hardware requirements, cost per proof, and how batching amortizes fixed proving costs across many users.
Analyze the security tradeoffs of optimistic rollup challenge periods. Calculate the minimum capital required for a fraud prover to be economically viable and the effective finality time for different withdrawal amounts.
Evaluate cross-chain bridge security models (trusted, optimistic, ZK-based) and calculate expected slippage and fees for a given transfer amount. Compare bridge options on security, speed, and cost dimensions.
Calculate optimal DAO treasury diversification allocations to reduce concentration risk. Model runway scenarios for different portfolio mixes of native token, stablecoins, ETH, and yield-generating assets.
Calculate DAO governance participation requirements, quorum thresholds, and vote passing conditions. Analyze voter apathy dynamics and minimum required participation for legitimate protocol governance decisions.
Compare the cost and security tradeoffs of off-chain Snapshot voting versus on-chain governance. Calculate total gas costs for on-chain votes, participation rates, and security considerations for each approach.
Calculate the minimum profit threshold for a flash loan arbitrage or attack scenario. Model the cost of the flash loan fee, gas costs, and slippage to determine whether a price discrepancy is large enough to exploit profitably.
Calculate MEV (Maximal Extractable Value) profitability for different searcher strategies: arbitrage, sandwich attacks, liquidations, and JIT liquidity. Model competition intensity and expected profit per block.
Estimate the probability and expected cost of a sandwich attack on a DEX trade based on slippage tolerance, trade size, and current gas prices. Calculate the optimal slippage setting to deter sandwich bots.
Analyze the economics of Just-In-Time (JIT) liquidity provision in Uniswap V3, where MEV searchers add concentrated liquidity immediately before a large trade then remove it after. Calculate profit margins and impact on regular LPs.
Calculate the total cost to mint NFTs on Ethereum at current gas prices. Model different minting scenarios (ERC-721, ERC-1155, batch minting) and compare costs across L1 and L2 networks.
Calculate the Net Present Value of an NFT collection's future royalty stream. Model expected secondary sales volume, royalty percentage, discount rate, and declining royalty enforcement to value creator earnings.
Calculate the rarity score and expected price premium for NFTs within a collection. Model trait rarity weighting and estimate the premium over floor price for rare trait combinations using statistical distribution.
Value metaverse land parcels using comparable sales analysis, proximity to high-traffic areas (plazas, roads, landmarks), and platform-specific metrics. Estimate per-unit pricing and total development ROI.
Analyze the economic balance of play-to-earn games by modeling token emission (faucets) against token consumption (sinks). Calculate sustainable token inflation rates and determine if game economics are viable long-term.
Calculate average revenue per daily active user (ARPDAU) for blockchain games. Model revenue from NFT sales, marketplace fees, token economics, and compare against traditional mobile game benchmarks.
Analyze the relationship between token reward reductions and player churn in Web3 games. Model optimal token incentive levels that retain genuine players while deterring pure farmers.
Evaluate the economic and social value of Soulbound Token (SBT) implementations. Model credential verification cost savings, reputation system efficiency gains, and governance participation improvements from non-transferable token identity.
Calculate the total cost of issuing and verifying decentralized identity attestations on various blockchains. Compare costs for KYC credential issuance, credential verification, and revocation across different DID methods.
Calculate the gas cost for issuing Verifiable Credentials (VCs) on Ethereum and alternative chains. Model batch issuance economics and on-chain vs off-chain credential anchoring cost tradeoffs.
Calculate the cost of resolving DID documents across different DID methods (did:ethr, did:ion, did:web, did:key). Compare resolution speed, cost, and trust model for each method.
Calculate monthly and annual costs for pinning content on IPFS via paid pinning services (Pinata, Infura, NFT.Storage). Compare costs for different storage volumes and estimate total NFT metadata hosting costs.
Calculate the one-time cost of permanently storing data on Arweave's permaweb. Compare against recurring IPFS pinning costs to determine the breakeven period and total cost of ownership for long-term storage.
Compare Filecoin storage deal prices across miners for different storage durations. Calculate verified deal rewards, retrieval costs, and compare total cost of ownership against IPFS pinning and Arweave.
Calculate the cost of indexing and querying blockchain data using The Graph Protocol. Estimate GRT token costs per 1000 queries, compare hosted service vs decentralized network pricing, and model total indexing costs.
Estimate the total cost of Chainlink oracle calls in smart contracts. Calculate gas costs for price feed consumption, VRF randomness requests, and automation keeper triggers at various gas prices.
Convert AI model training compute requirements (FLOPs) into GPU hours and training cost. Model different GPU types, batch sizes, and efficiency factors to estimate total training budget for neural network experiments.
Apply neural scaling laws to predict model performance given compute budget. Uses power-law relationships between compute, parameters, and data to forecast benchmark scores and capability thresholds for planned training runs.
Calculate the optimal model size and training tokens ratio using Chinchilla scaling laws. Determine whether a planned model is compute-optimal given your data budget, or find the ideal parameter count for a fixed compute budget.
Calculate LLM inference throughput in tokens per second for a given model size and GPU configuration. Estimate cost per token, compare GPU hardware options, and determine optimal batch sizes for latency vs throughput tradeoffs.
Calculate GPU memory bandwidth utilization for AI workloads. Determine whether a model is compute-bound or memory-bound, identify optimization opportunities, and estimate theoretical maximum throughput given hardware specifications.
Calculate CUDA core utilization efficiency for AI training workloads. Identify inefficiencies from poor kernel fusion, suboptimal batch sizes, and data pipeline bottlenecks that reduce effective GPU utilization below 50%.
Calculate the all-reduce communication overhead for tensor-parallel distributed training. Model inter-GPU bandwidth requirements, scaling efficiency, and optimal tensor parallelism degree for different model sizes and network topologies.
Calculate the pipeline bubble fraction that reduces throughput in pipeline-parallel training. Optimize micro-batch scheduling to minimize idle GPU time across pipeline stages and maximize hardware utilization.
Calculate the effective communication reduction from gradient compression techniques (top-K sparsification, PowerSGD, 1-bit Adam) in data-parallel training. Model accuracy loss vs communication savings tradeoffs.
Calculate the effective compute cost of Mixture of Experts (MoE) models. Determine active parameter fraction per forward pass, routing overhead, expert utilization balance, and compare inference cost against dense model equivalents.
Calculate the inference speedup from early exit strategies in transformer models. Model the accuracy/speed tradeoff at different exit thresholds and estimate average compute reduction across a real workload distribution.
Calculate the speedup from speculative decoding based on draft model acceptance rate and token speculation length. Optimize the draft model size vs acceptance rate tradeoff to maximize throughput for a given target model.
Calculate the GPU memory required for KV cache storage in transformer inference. Model the impact of sequence length, batch size, model architecture, and quantization on KV cache memory to optimize serving infrastructure.
Analyze the impact of attention sink tokens on transformer efficiency. Calculate how initial tokens absorb disproportionate attention, enabling KV cache eviction strategies and streaming LLM implementations for unlimited context.
Compare LoRA adapter parameter count and training cost against full fine-tuning. Calculate memory savings, training time reduction, and the quality tradeoff for different LoRA ranks across model sizes from 7B to 70B parameters.
Compare parameter-efficient fine-tuning methods: LoRA, prefix tuning, prompt tuning, adapter layers, and IA3. Analyze memory efficiency, training speed, and task-specific performance across different PEFT approaches.
Calculate the inference latency overhead introduced by adapter layers and LoRA modules during deployment. Model the impact of adapter rank, number of adapted layers, and hardware characteristics on per-token generation speed.
Calculate the memory savings and expected accuracy loss from different quantization schemes (FP16, INT8, INT4, GPTQ, AWQ). Compare quantization methods and determine optimal precision for your quality/cost requirements.
Calculate the actual hardware speedup achievable from structured neural network pruning. Distinguish between unstructured sparsity (limited hardware benefit) and structured pruning (real speedup on standard hardware).
Calculate the knowledge distillation effectiveness using KL divergence between teacher and student probability distributions. Optimize temperature parameter and loss weighting to maximize student model quality at a given size.
Calculate the optimal ratio of synthetic to real training data to maximize model quality. Model diminishing returns from synthetic data scaling and estimate the synthetic data quality threshold needed for improvement over real-data-only training.
Calculate the compute cost of Constitutional AI training, including the self-critique and revision rounds required to instill constitutional principles. Model iteration costs and compare against traditional RLHF annotation costs.
Calculate the total cost of collecting human preference data for RLHF (Reinforcement Learning from Human Feedback). Model annotator wages, annotation quality controls, and the total preference pairs needed for different model sizes.
Model the relationship between preference dataset size and downstream alignment quality. Estimate the diminishing returns curve and determine the minimum preference data needed to achieve target alignment scores.
Estimate the alignment tax: the capability reduction from safety fine-tuning procedures. Quantify performance drops on capability benchmarks versus safety improvements, helping researchers optimize safety-capability tradeoffs.
Calculate and compare AI red team attack success rates against different defense strategies. Model jailbreak attempt volumes, success rates per category, and estimate the expected safety improvement from layered defenses.
Score and categorize AI jailbreak attempts by severity and impact. Classify jailbreaks across categories (CSAM, weapons, fraud, privacy), estimate real-world harm potential, and prioritize defense investments.
Estimate AI model hallucination rates based on training data contamination analysis. Model the relationship between unseen fact density, retrieval quality, and factual accuracy across different knowledge domains.
Compare factual accuracy of RAG (retrieval-augmented generation) versus parametric memory in LLMs. Calculate consistency improvement from adding retrieval, cost-accuracy tradeoffs, and optimal retrieval chunk sizes.
Model the relationship between chain-of-thought reasoning depth (steps, tokens) and task accuracy across different problem types. Determine optimal CoT length for math, coding, and logical reasoning tasks.
Benchmark tool-using AI agent success rates across different domains (web search, code execution, calculator, API calls). Estimate task completion rates and failure mode distributions for planning agent architectures.
Calculate the coordination overhead and total cost of multi-agent AI systems. Model message passing costs, context duplication, error propagation, and compare against single-agent approaches for different task types.
Calculate the total LLM API cost per successfully completed autonomous agent task. Model iteration depth, tool call costs, context window consumption, and failure rate to estimate real operational costs.
Calculate the maximum feasible circuit depth for a given number of qubits based on coherence times and gate fidelities. Determine which quantum algorithms are executable on current hardware versus future fault-tolerant systems.
Calculate the number of physical qubits required per logical qubit for different quantum error correction codes (surface code, Shor code). Determine overhead requirements given current hardware error rates.
Calculate Quantum Volume (QV) for a quantum processor based on qubit count, connectivity, gate fidelity, and circuit depth. QV is IBM's hardware-agnostic benchmark for practical quantum capability.
Calculate the quantum speedup advantage for specific problem types (sampling, factoring, optimization, simulation). Compare quantum algorithm complexity against best classical algorithms to identify when quantum advantage applies.
Compare quantum annealing (D-Wave) against classical optimization methods (simulated annealing, genetic algorithms) for combinatorial problems. Calculate problem size thresholds where quantum annealing may offer advantage.
Compare Quantum Support Vector Machine (QSVM) kernel performance against classical SVM kernels. Evaluate data encoding methods, quantum kernel estimation costs, and identify problem classes where quantum kernels may provide advantage.
Calculate the secure key generation rate for BB84 quantum key distribution protocol. Model channel loss, detection efficiency, error rate, privacy amplification overhead, and net secure key rate at different transmission distances.
Calculate key and ciphertext sizes for NIST-selected post-quantum cryptographic algorithms (Kyber, Dilithium, Falcon). Compare overhead versus classical RSA/ECC and estimate migration costs for different security levels.
Calculate the rate of entangled qubit pair distribution across quantum network links. Model channel loss, Bell state measurement success probability, and expected entanglement generation rate for a quantum internet architecture.
Calculate the fidelity of entangled states delivered by a quantum repeater chain as a function of distance. Model entanglement purification overhead, decoherence during storage, and optimal repeater spacing.
Calculate signal loss for quantum communication links via satellite. Model diffraction loss, atmospheric turbulence, pointing accuracy, and expected photon detection rate for different satellite orbit altitudes and aperture sizes.
Calculate statistical tests for quantum random number generator (QRNG) output bias. Apply NIST SP 800-90B tests, chi-square analysis, and entropy estimation to verify randomness quality for cryptographic applications.
Calculate the positioning accuracy improvement from quantum optical clocks versus current GPS atomic clocks. Model timing precision, signal latency, and translate timing accuracy into positioning error for navigation applications.
Calculate the field sensitivity of quantum magnetometers (SQUID, atomic, NV-center) for different applications. Compare sensitivity, bandwidth, and operating conditions for medical imaging, geophysical survey, and navigation.
Calculate the precision and survey capability of atom-interferometry-based quantum gravimeters. Compare against classical gravimeters for mineral exploration, underground void detection, and geodesy applications.
Calculate the cost of running quantum algorithms on cloud quantum computers (IBM, AWS Braket, Azure Quantum, IonQ). Compare cost per shot across hardware types and estimate total experiment costs for research applications.
Calculate whether a quantum hardware platform can achieve fault-tolerant computation based on its physical gate error rate versus the fault-tolerance threshold. Model surface code and other QEC code overhead requirements.
Estimate timelines to fault-tolerant logical qubit realization based on current hardware progress trajectories. Model qubit count scaling, error rate improvement trends, and milestones required for commercially relevant quantum advantage.
Estimate the total cost of Ethereum transactions in USD and ETH. Enter gas units, gas price in Gwei, and current ETH price to get accurate transaction fees.
Convert Ethereum gas fees from Gwei to USD instantly. Input the gas price in Gwei, gas limit, and ETH market price to calculate the exact fee in dollars.
Calculate the cost of Solana transactions in USD. Solana fees are based on the number of signatures and a base fee per signature, making them extremely low.
Estimate BNB Smart Chain transaction fees in USD. Enter gas limit, gas price in Gwei, and BNB price to calculate the total cost of your BSC transaction.
Calculate Polygon (MATIC) transaction fees in USD. Enter gas units, gas price, and current MATIC price to get the total cost of transactions on Polygon.
Estimate transaction fees on Arbitrum One in USD. Arbitrum uses Ethereum for security but posts compressed transaction data, resulting in significantly lower fees.
Calculate Optimism (OP) network transaction fees in USD. Optimism is an Ethereum Layer 2 optimistic rollup that reduces gas costs while inheriting Ethereum security.
Estimate Avalanche C-Chain transaction fees in USD. Avalanche uses EIP-1559 dynamic fee pricing with AVAX as the fee token, burned to reduce supply.
Calculate Fantom Opera network transaction fees in FTM and USD. Fantom offers ultra-low fees due to its Directed Acyclic Graph (DAG) consensus architecture.
Estimate zkSync Era transaction fees in USD. zkSync uses ZK-rollup technology to batch thousands of transactions into a single validity proof posted to Ethereum.
Calculate impermanent loss when providing liquidity to AMM pools. Compare your LP position value versus simply holding the tokens to quantify the cost of liquidity provision.
Calculate your share percentage and token amounts when adding liquidity to an AMM pool. Determine how much of the pool you own and your proportional fee earnings.
Estimate the price impact of your trade on automated market maker pools. Large trades relative to pool size cause significant slippage using the constant product formula.
Calculate the minimum acceptable output for a DeFi swap given your slippage tolerance percentage. Protect against front-running and price movements during transaction confirmation.
Convert between Annual Percentage Yield (APY) and Annual Percentage Rate (APR) for DeFi protocols. Understand the effect of compounding frequency on your real yield.
Calculate yield farming returns including token rewards, trading fees, and impermanent loss. Get a realistic net ROI estimate for providing liquidity on DeFi protocols.
Estimate annual staking rewards for proof-of-stake cryptocurrencies. Enter your stake amount, current APY, and lock period to calculate expected earnings.
Calculate annual ETH staking rewards for Ethereum validators. Requires 32 ETH to run a validator node. Estimate consensus layer rewards, execution layer tips, and MEV.
Calculate NFT creator royalties on secondary sales. Enter the sale price and royalty percentage to find creator earnings after marketplace fees on platforms like OpenSea and Blur.
Calculate return on investment for NFT purchases based on floor price changes. Account for gas fees, marketplace commissions, and royalties to get net profit or loss.
Model token vesting schedules for team allocations, investor tranches, and protocol incentives. Calculate tokens unlocked over time with cliff and linear vesting combinations.
Calculate cliff and linear token vesting unlock amounts by date. Define the total allocation, cliff duration, vesting period, and TGE unlock percentage to generate the full schedule.
Generate a complete token unlock schedule showing monthly release amounts and cumulative unlocked supply. Identify unlock events that may create selling pressure.
Calculate your voting power percentage in a DAO based on your token holdings relative to total governance token supply. Assess your influence on protocol proposals.
Calculate voting weight using quadratic voting, where voting power equals the square root of tokens held. Reduces plutocratic dominance and gives minority stakeholders more influence.
Determine whether a DAO proposal meets quorum requirements. Input participating votes, total supply, and the quorum percentage to check if a vote is valid.
Calculate potential profit from flash loan arbitrage between DeFi exchanges. Account for flash loan fees, gas costs, price differences, and slippage to estimate net gain.
Estimate fees for bridging assets between blockchain networks. Compare bridge protocol costs, including relayer fees, liquidity provider fees, and destination chain gas for major bridges.
Compare the true cost of trading on centralized (CEX) vs decentralized (DEX) exchanges. Factor in trading fees, gas costs, spreads, and withdrawal fees for an accurate comparison.
Calculate the liquidation price for leveraged cryptocurrency positions. Enter entry price, leverage ratio, and maintenance margin to find exactly where your position gets liquidated.
Calculate the cumulative cost or income from funding rates on perpetual futures contracts. Positive funding means longs pay shorts; negative funding means shorts pay longs.
Calculate profit from crypto cash-and-carry (basis) trades: long spot + short futures to capture the premium. Estimate annualized return after funding, borrow, and transaction costs.
Calculate the interest cost of borrowing funds for margin trading on crypto exchanges. Enter borrowed amount, daily interest rate, and holding period to find total interest paid.
Calculate optimal liquidity range for Uniswap V3 concentrated liquidity positions. Determine capital efficiency, fee earnings, and impermanent loss for a given price range.
Estimate fee income from concentrated liquidity market maker (CLMM) positions. Calculate earnings based on trading volume, pool fee tier, your liquidity share, and time in-range.
Calculate Uniswap V3 tick spacing, tick indices, and price boundaries for liquidity positions. Convert between price ranges and tick values for smart contract interactions.
Analyze Curve Finance stablecoin pool depth and expected slippage for large swaps. Curve's StableSwap invariant provides extremely low slippage for pegged assets.
Calculate automatic portfolio rebalancing via Balancer weighted pools. Determine how arbitrageurs rebalance your pool back to target weights as prices change.
Calculate the results of dollar cost averaging (DCA) into Bitcoin, Ethereum, or any crypto asset. Compare DCA returns vs. lump-sum investing across various market conditions.
Calculate expected Bitcoin ROI based on historical halving cycles. Analyze price performance in the 12–18 months following each halving event to model future cycle returns.
Calculate Bitcoin and cryptocurrency mining profitability. Enter hash rate, power consumption, electricity cost, pool fees, and hardware cost to get daily, monthly, and break-even projections.
Convert mining hash rate (TH/s, PH/s) directly to estimated daily revenue in USD. Uses current network difficulty and block reward to calculate expected mining earnings per unit of hash power.
Predict Bitcoin mining difficulty adjustments based on current block times. Bitcoin adjusts difficulty every 2016 blocks to maintain a 10-minute average block time.
Calculate US short-term capital gains tax on crypto assets held under 12 months. Short-term gains are taxed as ordinary income at your marginal tax rate.
Calculate US long-term capital gains tax on crypto assets held over 12 months. Long-term rates (0%, 15%, or 20%) are significantly lower than short-term rates.
Calculate the compound annual growth rate (CAGR) of a DeFi protocol's Total Value Locked (TVL). Assess protocol adoption velocity and compare growth rates across DeFi categories.
Compare transactions per second (TPS) across blockchain networks. Calculate theoretical max TPS and estimate confirmation times based on block size, block time, and transaction size.
Calculate potential gas savings from gas tokens (like GST2/CHI) and EIP-2929 storage refunds. Estimate optimal minting and burning strategy to reduce Ethereum transaction costs.
Estimate the gas cost of verifying Merkle proofs in Ethereum smart contracts. Calculate proof length, hashing operations, and total gas for whitelist mints and airdrop claims.
Estimate the cost of a smart contract security audit based on code complexity, lines of code, and audit firm tier. Compare audit costs versus potential hack losses to justify security investment.
Calculate the GPU VRAM required to run large language model inference. Input model parameter count, precision (FP16/INT8/INT4), and batch size to estimate memory usage in GB.
Estimate total GPU memory required for training a neural network. Accounts for model parameters, gradients, optimizer states, activations, and batch size in FP32/FP16/BF16.
Calculate the total number of trainable parameters in a transformer model. Enter number of layers, hidden size, feedforward size, vocabulary size, and heads for an exact count.
Estimate the floating-point operations (FLOPs) in a single transformer forward pass. Provide sequence length, batch size, layers, hidden size, and feedforward dimension.
Compute the optimal training budget following the Chinchilla scaling laws. Given a compute budget in FLOPs, find the ideal model size and number of training tokens for maximum efficiency.
Estimate the time-to-first-token and per-token generation latency for large language models. Inputs include model FLOPs, GPU TFLOP/s, batch size, and memory bandwidth.
Calculate the token-per-second throughput of an LLM deployment. Enter GPU FLOP/s, memory bandwidth, model parameters, and serving batch size to benchmark expected performance.
Calculate the GPU memory required for a given context window length. Accounts for KV-cache, attention scores, and activation memory as sequence length scales.
Estimate the KV-cache memory footprint for transformer inference. Inputs include number of layers, number of heads, head dimension, sequence length, batch size, and precision.
Calculate the memory reduction from quantizing a model from FP32 or FP16 to INT8, INT4, or GPTQ formats. See percentage savings and required VRAM before and after quantization.
Calculate the number of trainable parameters added by LoRA (Low-Rank Adaptation) fine-tuning. Enter rank r, target modules, and model hidden size to see adapter size vs full model.
Estimate the total FLOPs and GPU-hours required to fine-tune a language model. Enter model size, dataset token count, number of epochs, and hardware TFLOP/s.
Estimate the total token count for a text dataset. Enter the total number of words, characters, or documents to convert to approximate token counts for GPT-style, BERT-style, or LLaMA tokenizers.
Estimate the total cloud compute cost to pre-train a large language model. Inputs include model parameters, training tokens, GPU type, utilization, and cloud price per GPU-hour.
Calculate the total inference cost per million tokens for self-hosted and API-based LLM deployments. Compare GPU rental, electricity, and per-token API pricing models.
Compare total monthly costs across major LLM API providers (OpenAI, Anthropic, Google, Cohere, Mistral). Enter monthly token volume to see cost breakdown per provider.
Estimate the RAM and storage required for a FAISS or similar vector database. Enter embedding dimension, number of vectors, index type (Flat, IVF, HNSW), and precision.
Model the recall-vs-latency trade-off for approximate nearest neighbor (ANN) search. Parameterize HNSW ef_search or IVF nprobe to find the operating point meeting your SLA.
Calculate monthly cloud storage cost for embedding vectors. Enter number of documents, embedding dimension, precision, and cloud storage pricing ($/GB/month) to get total cost.
Estimate end-to-end latency for a Retrieval-Augmented Generation (RAG) pipeline. Model query embedding, ANN retrieval, reranking, context assembly, and LLM generation latency.
Calculate the number of chunks and total tokens produced by different chunking strategies for RAG. Compare fixed-size, sentence-based, and semantic chunking for your document corpus.
Estimate latency for cross-encoder reranking in RAG pipelines. Enter number of candidate passages, passage length, and cross-encoder model size (ms per passage) to compute total reranking time.
Estimate the total API cost and latency for an LLM-based agentic loop. Input number of reasoning steps, average tokens per step, tool-call cost, and LLM price per million tokens.
Estimate the cumulative fidelity of a quantum circuit given single-qubit and two-qubit gate fidelities. Calculate how error accumulates over a sequence of gate operations.
Calculate the depth and T-gate count of a quantum circuit. Enter the number of single-qubit, two-qubit, and T-gates to estimate total circuit depth and resource requirements.
Determine whether a physical qubit's error rate is below the fault-tolerance threshold for a chosen error-correcting code (surface code, Steane, color code). Estimate the required code distance.
Estimate the number of physical qubits required to encode logical qubits using the surface code. Enter physical error rate, target logical error rate, and desired number of logical qubits.
Calculate or estimate the Quantum Volume (QV) of a quantum processor. QV = 2^n where n is the largest square circuit a device can successfully execute, combining qubit count, connectivity, and fidelity.
Estimate whether a quantum circuit is beyond classical simulation capability. Enter qubit count, circuit depth, two-qubit gate fidelity, and classical simulation hardness to evaluate supremacy claims.
Estimate the number of quantum circuit executions (shots) and total compute time needed to run a Variational Quantum Eigensolver (VQE) optimization. Enter ansatz depth, parameters, and shots per iteration.
Estimate the expected approximation ratio for the Quantum Approximate Optimization Algorithm (QAOA) at a given circuit depth p. Compare against classical algorithms for MaxCut and combinatorial problems.
Calculate the secure key rate for a BB84 quantum key distribution protocol. Enter photon detection efficiency, channel loss (dB), dark count rate, and QBER to compute final secure bit rate.
Calculate the entanglement generation rate and fidelity for a quantum repeater link. Enter link segment distance, fiber loss, memory coherence time, and Bell measurement fidelity.
Estimate the entanglement generation rate between two quantum nodes. Inputs include photon source repetition rate, coupling efficiency, fiber loss, and heralding detector efficiency.
Calculate whether a quantum memory's coherence time is sufficient for a given quantum network protocol. Compare T2 coherence time against communication round-trip and gate operation times.
Calculate the system-level photon detection efficiency combining SNSPD detector efficiency, coupling losses, and fiber transmission. Estimate coincidence detection probability for entanglement experiments.
Estimate the fidelity of a Bell state measurement (BSM) given detector efficiency, timing jitter, and optical mode mismatch. Critical for quantum teleportation and entanglement swapping protocols.
Calculate the overall success probability and fidelity for quantum state teleportation given entanglement fidelity, Bell state measurement efficiency, and classical communication latency.
Estimate the logical qubit coherence time improvement expected from topological qubit encoding (Majorana-based). Compare physical vs topological qubit lifetimes for a given system temperature and gap energy.
Estimate the qubit and time overhead for distilling high-fidelity T-gate magic states from noisy physical magic states using the 15-to-1 or Reed-Muller distillation protocols.
Calculate the logical error rate for a stabilizer quantum error-correcting code (surface, Steane, color code) as a function of physical error rate and code distance d.
Calculate FLOPs for common neural network architectures (CNN, RNN, MLP, Vision Transformer). Enter layer dimensions, kernel sizes, and sequence lengths for an exact FLOP count.
Explore the GPU memory vs throughput trade-off for different training batch sizes. Calculate activation memory, gradient memory, and maximum batch size given available VRAM.
Estimate communication overhead for distributed deep learning training. Calculate AllReduce gradient synchronization time across N GPUs given model size, network bandwidth, and parallelism strategy.
Calculate the maximum request throughput for a deployed LLM serving system. Account for batch size, sequence length, GPU TFLOP/s, memory bandwidth, and continuous batching efficiency.
Calculate your effective GPU utilization efficiency for ML training and inference. Compare achieved FLOP/s against peak TFLOP/s to diagnose memory-bound, compute-bound, or I/O-bound bottlenecks.
Estimate the total monthly infrastructure cost of an MLOps pipeline including data preprocessing, model training, experiment tracking, serving, and monitoring on cloud or on-premises hardware.
Calculate the total cost of labeling a dataset for supervised ML. Inputs include dataset size, labeling task type, annotator rate, quality review overhead, and platform fees.
Estimate the quality score of synthetic data for ML training using fidelity, diversity, and privacy metrics. Compare against real data baselines using statistical distance measures.
Estimate the CO₂ equivalent emissions from training an AI model. Enter GPU-hours, data center PUE, carbon intensity of electricity grid (gCO₂/kWh), and GPU TDP to compute total carbon cost.
Calculate precision = TP/(TP+FP), recall = TP/(TP+FN), and F1 = 2×(P×R)/(P+R) from a confusion matrix. Essential metrics for evaluating classification model performance.
Compute overall classification accuracy = (TP+TN)/(TP+TN+FP+FN) from a binary confusion matrix. Includes per-class accuracy breakdown.
Estimate the ROC AUC score from true positive rate (TPR) and false positive rate (FPR) threshold pairs using the trapezoidal rule. AUC = 1 is perfect; AUC = 0.5 is random.
Calculate MCC = (TP×TN − FP×FN) / √((TP+FP)(TP+FN)(TN+FP)(TN+FN)). MCC ranges −1 to +1 and is robust to class imbalance.
Compute binary cross-entropy log loss = −(1/N)Σ[y·log(p) + (1−y)·log(1−p)] from predicted probabilities and true labels. Lower log loss indicates a better calibrated model.
Calculate Cohen's kappa κ = (po − pe)/(1 − pe) to measure inter-rater or classifier agreement beyond chance. κ = 1 is perfect; κ = 0 is chance-level.
Derive sensitivity (TPR), specificity (TNR), false positive rate (FPR), false negative rate (FNR), positive predictive value (PPV), and negative predictive value (NPV) from raw confusion matrix counts.
Compute balanced accuracy = (TPR + TNR) / 2, averaging sensitivity and specificity. Robust metric for imbalanced datasets where overall accuracy is misleading.
Calculate the monthly utilisation threshold above which a 1-year Reserved Instance is cheaper than On-Demand pricing for an EC2 instance type. Includes partial upfront and no-upfront comparisons.
Find the monthly invocation count at which AWS Lambda becomes more expensive than a continuously running EC2 instance, factoring in memory size, average duration, and request pricing.
Determine the optimal S3 storage class based on retrieval frequency. Calculates monthly cost for S3 Standard, Standard-IA, and Glacier given storage size and access patterns.
Compare monthly cost of AWS EBS gp3 and io2 volumes at a given capacity and IOPS target. Identifies when io2 provisioned IOPS becomes cost-justified over gp3 baseline.
Compare total cost of ownership (TCO) for Amazon RDS Multi-AZ versus self-managed PostgreSQL/MySQL on EC2, including licensing, operations, storage, backup, and support costs.
Estimate monthly CDN data transfer costs across CloudFront, Cloudflare, Fastly, and Akamai based on total GB served, cache hit ratio, and regional traffic distribution.
Calculate the vCPU/memory configuration at which AWS Fargate pricing equals EC2 Spot pricing for containerised workloads, accounting for Spot interruption probability and task startup time.
Calculate the theoretical maximum TCP throughput = Window Size / RTT. Helps identify whether bandwidth or latency is the bottleneck in long-distance file transfers.
Apply Little's Law L = λW to calculate average queue length (L), arrival rate (λ), or average wait time (W) in a queuing system. Foundation of network and systems capacity planning.
Calculate BDP = Bandwidth × RTT (in bits) — the amount of data in flight on a network path at any instant. Determines the optimal TCP socket buffer size for full link utilisation.
Estimate TCP throughput degradation from packet loss using the Mathis formula: Throughput ≈ (MSS / RTT) × (1 / √p). Shows how even 0.1% loss drastically reduces throughput on long-distance links.
Model how round-trip time (RTT) affects total file transfer time for various file sizes over TCP, accounting for TCP slow start, connection establishment, and TLS handshake overhead.
Calculate bandwidth overhead from IP fragmentation when packet size exceeds path MTU. Estimates efficiency loss from fragmentation headers and retransmission of fragmented packets.
Quantify the impact of packet inter-arrival jitter on real-time applications (VoIP, video). Calculates required jitter buffer size and effective one-way delay increase.
Model the cumulative impact of DNS resolution time on page load performance across multiple resources, factoring in TTL caching, parallel lookups, and DNS prefetch directives.
Calculate index selectivity = distinct values / total rows. High selectivity (close to 1.0) makes an index effective; low selectivity means a full scan is often faster.
Calculate effective storage IOPS required given a cache hit ratio and application request rate. Determines the minimum storage IOPS needed after accounting for in-memory cache absorption.
Determine optimal database connection pool size using the formula pool = cores × 2 + effective_spindle_count (HikariCP guideline). Avoid over-pooling and the associated context-switching overhead.
Estimate on-disk space consumed by a B-tree index given row count, key column size(s), and fill factor. Useful for capacity planning and identifying bloated indices.
Model relative I/O cost of sequential table scan vs index scan for a given table size, result fraction, and random vs sequential page cost ratio. Mirrors PostgreSQL planner cost model.
Quantify the risk of serving stale data from a read replica given replication lag in milliseconds and the application's staleness tolerance. Models lag probability distributions.
Evaluate a candidate sharding key's cardinality and distribution to predict shard balance, hotspot probability, and cross-shard query overhead for horizontal database partitioning.
Calculate Mean Time to Recovery (MTTR) = total downtime / number of failures. Track incident trends and set recovery time objectives (RTO) for service level agreements.
Compute MTTF = total operating time / number of failures for non-repairable or repairable systems. Assesses component reliability and informs redundancy decisions.
Calculate Mean Time Between Failures (MTBF) = MTTF + MTTR for repairable systems. Used to model fleet reliability, schedule preventive maintenance, and set spare-parts inventory.
Calculate system availability A = MTTF / (MTTF + MTTR) = MTTF / MTBF. Converts to percentage uptime and maps to SLA nines (99.9%, 99.99%, etc.) with equivalent annual downtime.
Classify your team's deployment frequency against DORA (DevOps Research and Assessment) tiers: Elite (multiple/day), High (daily–weekly), Medium (weekly–monthly), Low (monthly+).
Compute change failure rate = deployments causing incidents / total deployments × 100. DORA elite benchmark: < 5%. Medium teams: 15–45%. Track trend over rolling 30/90-day windows.
Calculate median (P50) and 95th percentile (P95) lead time from commit to production. DORA elite benchmark: P50 < 1 day. Identifies long tail deployments dragging cycle time.
Estimate financial exposure from SLA breach penalties given downtime duration, contracted uptime level, per-minute revenue loss, and contractual service credits as a percentage of monthly fees.
Calculate engineer on-call burden: pages per week, after-hours interruptions, average time to resolve, and equivalent lost working hours. Identifies unsustainable on-call load before burnout occurs.
Measure alert fatigue as false positive ratio = non-actionable alerts / total alerts. Identifies when alert noise is suppressing genuine incident detection.
Calculate remaining error budget from a service level objective (SLO). Error budget = 100% − SLO target. Shows remaining allowed downtime/error rate in seconds per period before SLO is breached.
Model the throughput-latency trade-off using queuing theory. As utilisation approaches 100%, latency grows hyperbolically. Finds the optimal operating point that maximises throughput within latency constraints.
Calculate optimal thread pool size using Amdahl's Law and CPU/IO ratio: threads = CPUs × (1 + wait_time / service_time). Balances CPU-bound and I/O-bound workload characteristics.
Project time to OOM (out of memory) crash based on current heap growth rate (MB/hour) and available memory. Calculates safe restart interval and leak rate from two heap snapshots.
Calculate CPU throttling headroom for containerised workloads (Kubernetes cgroups). Estimates how close a pod is to its CPU limit and probability of throttling at peak load.
Calculate effective throughput reduction from GC stop-the-world pauses: throughput = (1 − GC_time/total_time). Maps GC overhead to P99 latency impact for latency-sensitive services.
Generate exponential backoff delay sequence: delay = base × 2^attempt + jitter. Calculate total time to exhaustion across N retries with configurable base, cap, and jitter factor.
Calculate circuit breaker open threshold, half-open probe interval, and close hysteresis based on error rate, latency SLO, and dependency recovery time characteristics.
Size isolated bulkhead thread pools for microservice dependencies. Allocates separate pools per downstream service so a slow dependency cannot exhaust the shared pool and cascade failures.
Configure token bucket rate limiter parameters: fill rate (tokens/second), bucket capacity (burst size), and token cost per request. Models burst tolerance and sustained rate enforcement.
Calculate password entropy H = L × log₂(N) bits, where L is length and N is the character set size. Estimates the theoretical information content and resistance to brute-force attack.
Estimate time to crack a password by brute force at a given hash rate (default 10¹² hashes/sec for modern GPU clusters). Converts entropy bits to expected crack time in seconds, hours, or years.
Estimate total data breach cost using IBM's Cost of a Data Breach model: per-record cost × records breached + fixed costs (detection, notification, post-breach response). Segment by industry and data type.
Compute the CVSS v3.1 Base Score from Attack Vector (AV), Attack Complexity (AC), Privileges Required (PR), User Interaction (UI), Scope (S), Confidentiality (C), Integrity (I), and Availability (A) metric values.
Quantify the risk reduction from multi-factor authentication (MFA) deployment. Microsoft research shows MFA blocks 99.9% of automated account compromise attempts. Models residual risk by MFA type (TOTP, push, FIDO2).
Calculate bcrypt hash time and GPU crack resistance based on cost factor (rounds = 2^cost). Determines the optimal cost factor for a target hash time of 100–500 ms on the server.
Estimate organisational phishing risk from industry click-through benchmark (average 7–12%), security awareness training frequency, and simulated phishing campaign results.
Assess SQL injection attack surface from number of parameterised vs string-concatenated queries, input validation coverage, WAF presence, and least-privilege database account usage.
Score the complexity of an XSS attack vector based on output context (HTML/attribute/JS/URL), encoding applied, CSP policy strictness, and browser rendering engine protections.
Assess CORS misconfiguration risk from Origin header reflection, wildcard Allow-Origin with credentials, pre-flight cache duration, and trusted origin whitelist quality.
Calculate clock period T = 1/f in nanoseconds from frequency in GHz, or derive frequency from a target clock period. Essential for digital circuit timing analysis and setup/hold time verification.
Calculate processor performance in MIPS (Millions of Instructions Per Second) = f(MHz) / CPI, where CPI is average cycles per instruction. Compares microarchitecture efficiency across CPU designs.
Compute CPU utilisation U = task_execution_time / total_time from task duration and period measurements. Calculate headroom before thermal throttling and estimate power draw at utilisation level.
Calculate struct/class memory padding bytes due to alignment requirements. Shows actual vs declared size and optimal field ordering to minimise padding waste in C/C++/Rust data structures.
Calculate CMOS dynamic power consumption P = α × C × V² × f, where α is activity factor, C is load capacitance, V is supply voltage, and f is clock frequency. Core formula for chip power budgeting.
Calculate static (standby) power dissipation P_static = I_leak × VDD for CMOS circuits. Leakage dominates at small process nodes and high temperatures; critical for IoT and mobile battery life.
Estimate worst-case interrupt latency for an embedded system from CPU pipeline depth, interrupt vector fetch cycles, context save cycles, and clock frequency.
Calculate theoretical ADC signal-to-noise ratio SNR ≈ 6.02N + 1.76 dB, where N is bit resolution. Computes ENOB (Effective Number of Bits) from measured SINAD.
Calculate average analog output voltage from PWM duty cycle: V_out = D × V_supply, where D is duty cycle (0–1). Includes RC filter time constant for ripple estimation.
Verify SPI interface timing margin from clock frequency, data setup time (t_su), hold time (t_h), and propagation delay. Calculates maximum SPI clock rate for a given PCB trace length.
Compute RF link budget received power P_rx = P_tx(dBm) + G_tx(dBi) + G_rx(dBi) − FSPL(dB) − cable/body losses(dB). Verify if received power exceeds receiver sensitivity.
Calculate free space path loss FSPL(dB) = 20×log₁₀(4πd/λ) = 20×log₁₀(d) + 20×log₁₀(f) + 92.4 for d in km and f in GHz. Fundamental for RF link budget analysis.
Calculate total noise figure of a cascaded receiver chain using the Friis formula: F_total = F1 + (F2−1)/G1 + (F3−1)/(G1×G2) + ... Essential for LNA and receiver chain design.
Calculate the theoretical maximum channel capacity C (bits/second) = B × log₂(1 + SNR) for a given bandwidth B (Hz) and signal-to-noise ratio SNR. The Shannon-Hartley theorem is the fundamental limit of all communications.
Convert energy per bit to noise density ratio (Eb/N0 in dB) to bit error rate (BER) for BPSK modulation: BER = (1/2)×erfc(√(Eb/N0)). Extends to QPSK and QAM constellations.
Calculate spectral efficiency in bits/s/Hz for common modulation schemes (BPSK, QPSK, 16-QAM, 64-QAM, 256-QAM, 1024-QAM) including code rate and MIMO multiplexing gain.
Calculate Doppler frequency shift Δf = f_c × v/c for a mobile transmitter or receiver moving at velocity v relative to carrier frequency f_c. Critical for mobile communications coherence bandwidth.
Calculate fade margin required to maintain link reliability at a target outage probability using Rayleigh or Rician fading models. Determines the extra dB needed above FSPL.
Calculate diversity gain from antenna diversity order, correlation coefficient, and target outage probability. Shows how spatial, temporal, or frequency diversity reduces required fade margin.
Calculate MIMO channel capacity increase vs SISO using min(M,N) spatial streams, where M = TX antennas and N = RX antennas. Models capacity scaling with SNR and antenna count per the Foschini-Gans theorem.
Model transistor count scaling per Moore's Law and estimate power implications under Dennard scaling breakdown. Calculate the expected transistor count for a given die size and process node.
Calculate average CPU TDP across P-states (performance states) given frequency/voltage pairs and activity-weighted time in each state. Maps measured power to thermal design requirements.
Calculate power-delay product (PDP) = P × t_d for a logic gate, measuring the energy consumed per switching event in femtojoules. Lower PDP indicates more energy-efficient gate design.
Compare threshold voltage and subthreshold swing for FinFET vs planar MOSFET. FinFETs have near-ideal subthreshold swing (~70 mV/decade) vs planar (~100 mV/decade) due to enhanced electrostatic control.
Model subthreshold and gate leakage scaling across CMOS process nodes (250nm to 3nm). Estimates leakage current density and fraction of total power at each technology generation.
Estimate CMOS gate propagation delay t_p = 0.69 × R_on × C_load for an inverter or logic gate. Model the impact of fan-out, wire capacitance, and transistor sizing on delay.
Calculate the FO4 (Fan-Out of 4) delay — the propagation delay of a minimum-size inverter driving 4 identical inverters. FO4 is the canonical technology-independent timing unit for VLSI design.
Calculate RC delay t = 0.38 × R × C (Elmore delay) for a global metal interconnect line. Shows how wire delay scales (poorly) vs gate delay at advanced nodes, driving the need for repeaters.
Calculate FinFET gate capacitance C_g per unit fin width from gate oxide thickness (t_ox), fin height (H_fin), and fin width (W_fin). Drives interconnect loading analysis for standard cell timing.
Calculate minimum feature size resolvable with EUV lithography using the Rayleigh criterion: R = k1 × λ / NA, where λ = 13.5 nm (EUV) and NA is numerical aperture (up to 0.55 for High-NA EUV).
Estimate IoT device battery life: T = C_battery / (I_sleep × (1 − D) + I_active × D), where D is active duty cycle. Calculates coin cell and AA battery longevity at various sleep/wake cycles.
Calculate LoRa link budget improvement and data rate trade-off for spreading factors SF7 to SF12. Models receiver sensitivity vs data rate across all spreading factors for LoRaWAN network planning.
Calculate Effective Number of Bits (ENOB) from measured SINAD (Signal to Noise and Distortion): ENOB = (SINAD_dB − 1.76) / 6.02. Quantifies real ADC performance vs theoretical N-bit resolution.
Calculate minimum sampling rate from Nyquist-Shannon theorem: f_s ≥ 2 × f_max (signal bandwidth). Shows aliasing frequency for under-sampling and anti-aliasing filter requirements.
Calculate Kalman gain K = P_pred × Hᵀ / (H × P_pred × Hᵀ + R) for a linear Kalman filter. Balances prediction uncertainty vs measurement noise for optimal sensor fusion (IMU + GPS, etc.).
Estimate Bluetooth Low Energy (BLE) range from TX power (dBm), receiver sensitivity, path loss exponent, and environmental factors. Models BLE 5.0 coded PHY (S=8) extended range.
Calculate end-to-end latency in a Zigbee mesh network from hop count, per-hop latency (typically 15–30 ms), and contention/retry overhead. Models battery impact of mesh routing.
Estimate NB-IoT device battery life targeting 10-year operation from battery capacity, PSM (Power Saving Mode) sleep current, eDRX interval, transmission power class, and reporting frequency.
Estimate MQTT broker throughput (messages/second) as a function of payload size, QoS level (0/1/2), network RTT, and broker processing time. Shows QoS overhead impact on publish rate.
Estimate MQTT broker memory and CPU requirements for a target concurrent connection count and publish rate. Models per-connection overhead for Mosquitto, HiveMQ, and EMQX.