Automated insulin delivery has improved glycemic outcomes, yet many patients still fall short of clinical targets — and existing reinforcement learning work optimizes insulin alone, leaving behavior untouched. GUIDE is a decision-support framework that complements AID by recommending structured actions defined by intervention type, magnitude, and timing, covering both bolus insulin and carbohydrate intake. It pairs a patient-specific glucose predictor trained on real CGM data with a unified environment that supports offline and online algorithms. Across 25 individuals, CQL-BC reached 85.49% time-in-range with low hypoglycemia exposure, and its learned policy stayed behaviorally plausible — a mean cosine similarity of 0.87 with real patient action patterns.

Automated insulin delivery systems still miss impending glycemic excursions, partly because forecasting models are trained to treat every error the same no matter where on the glucose range it falls. GLIMMER is an architecture-agnostic training framework that moves the fix into the loss function: a genetic algorithm tunes region-specific penalties so mistakes inside the hypo- and hyperglycemic ranges cost the model the most. Evaluated on OhioT1DM and the newly collected AZT1D dataset, it improves RMSE by up to 24.6% and MAE by 29.6% over baseline architectures, and reaches 98.4% recall on dysglycemic events using only 10K parameters — against baselines carrying millions.

Data-driven work in type 1 diabetes keeps running into the same wall: the publicly available datasets are either simulated or drawn from very small cohorts, and almost none of them record what the pump actually did. AZT1D closes part of that gap with 6–8 weeks of naturalistic data per participant — 320,488 CGM entries across 26,707 hours of monitoring — pairing Dexcom G6 Pro readings with insulin delivery logs, carbohydrate intake, and pump device mode (regular, sleep, exercise). Its distinguishing feature is the granularity on bolus events: total dose, bolus type (standard, correction, automatic), and the split between correction and food insulin, fields that are rarely exposed elsewhere. Assembling it meant reconciling two incompatible Tandem t:slim X2 exports, with hourly basal rates and device modes recovered from PDF reports through coordinate-based cropping and OCR. A second release is planned, expanding the cohort to up to 100 patients.

CGM and pump records describe what glucose did, not what the person did — and the lifestyle half of that picture is exactly what gets lost when studies rely on third-party trackers. ExActHealth is a custom mobile application for structured food, health monitoring, and physical activity data collection, paired with a smartwatch and built natively on both Android and iOS, with the Android client developed end to end by me. Participants log meals with name, timestamp, and macronutrients (carbohydrate required, protein and fat optional), optionally attaching photos, and can save frequently eaten foods so a repeat entry takes one tap instead of a full form. The app reads heart rate, step count, sleep duration, and workout sessions from the paired watch and syncs everything to a private cloud server; no personally identifiable information is collected, and participants sign in with study-specific credentials issued at enrollment. The 30-day pilot ran on iOS with an Apple Watch Series 10 across 20 patients at Mayo Clinic Arizona: 87% rated the app easy to use and 73% said it supported their diabetes self-management, while the smartwatch scored 100% on ease of use and 87% on perceived help with management. Presented as a poster at IEEE BHI 2025.

Existing dietary recommendation systems tend to be rigid, ignore real-world constraints such as which ingredients are actually available, and demand so much user input that nobody keeps using them. NutriGen builds a personalized nutrition database and uses prompt engineering to ground LLM-generated meal plans in the USDA nutrition database, keeping the output structured and practical while asking very little of the user. Across the models evaluated, Llama 3.1 8B and GPT-3.5 Turbo came closest to user-defined caloric targets at 1.55% and 3.68% error; DeepSeek V3 lagged at 10.45% MAE and was considerably slower to generate.

NEAT evolves a network’s topology and its weights together, which works well until the input gets large — with raw pixels it can no longer build a well-tuned network. This work introduces self-attention as an indirect encoding: attention selects the most important regions of the input before the evolved network ever sees them, and a hybrid scheme handles the final weight optimization. On Atari games with raw pixel input, the method reaches scores comparable to other evolutionary approaches while using a far smaller number of parameters, lifting the dimensionality restriction that constrained the original algorithm.

A deep-learning take on the classic smartphone activity problem: given a short window of raw motion data, decide which of six activities the wearer is performing. Convolutional layers learn features directly from the 50 Hz accelerometer and gyroscope signal, so none of the hand-crafted window statistics that classical tree-based approaches depend on are needed, and an LSTM head reads the temporal order across the window. Trained on the UCI Human Activity Recognition dataset — 30 subjects wearing a waist-mounted phone — the model reaches roughly 88–92% accuracy across the six activity classes.

The Winton Stock Market Challenge asked competitors to forecast the short-term returns of anonymised stocks. Every sample is a five-day window: the model sees two days of history plus the first two hours of minute-by-minute intraday returns, and has to predict 62 target values — the rest of that day and the next two daily returns. The masked features are deliberately undisclosed and financial returns sit close to noise, so the difficulty is resisting the temptation to fit it. This repository is a compact, readable Keras baseline over 147 min-max scaled inputs, training a small fully connected network one target column at a time across both horizons.

In the clustered traveling salesman problem the cities are partitioned into groups, and a valid tour has to finish every city in a group before moving on to the next one. This C++ implementation follows the two-level genetic algorithm, which evolves the paths inside each cluster and the ordering between clusters together rather than optimizing one level and then the other. The same machinery extends to plain large-scale TSP instances: cluster the cities first, then solve the resulting CTSP, which converges faster than running a classical genetic algorithm across the whole instance.

A clustering algorithm that measures similarity with the straight-line Euclidean distance quietly assumes its clusters are compact and roughly spherical, and fails when they are not — faced with two concentric rings, k-means cuts them both in half. This implementation swaps in the Euclidean Commute Time distance: a graph built from nearest neighbours plus the minimum spanning tree is read as a Markov chain, so two points count as close when a random walker travels between them easily — the shape of the data, not the straight line, decides what is near. Scored by normalized mutual information across six datasets, it recovers well separated clusters of arbitrary shape.

Real datasets are rarely complete, and neither easy option is satisfying: dropping every affected record throws away information that is often scarce, while filling the gaps with a constant distorts the distribution later stages depend on. This implementation runs two estimators over the damaged data — a support vector regression model trained on the complete rows, and a fuzzy c-means estimator that rebuilds an entry as the membership-weighted combination of cluster centers. Rather than tuning the fuzzy parameters by hand, a genetic algorithm searches over cluster size and weighting factor until the two estimators agree. Evaluated on six UCI datasets by RMSE against the values it replaced.

Tic-Tac-Toe cannot reliably be won — against a competent opponent a large share of games end in a draw, so the best a player can hope for is not to lose — which makes it an appealing test bed for optimisation: the board is small enough to enumerate exactly, while the space of strategies is far too large to search exhaustively. This C++ implementation collapses the legal boards to 765 unique states, merging the eight rotations and reflections of each, so an individual is simply a list of 765 moves. Strategies are scored by the fraction of games lost against the whole population and evolved by tournament selection, two-point crossover and single-state mutation.

A fraudulent purchase rarely looks wrong on its own — what gives it away is that it does not fit the way that particular cardholder usually spends — so detection is better posed as a question about the sequence of transactions, and has to be learned without labelled examples of fraud. This Python implementation clusters raw amounts into spending levels such as low, medium and high (k-means by default, with DBSCAN and linkage variants provided), then trains a hidden Markov model over the resulting symbols with Baum-Welch re-estimation. A new transaction joins the recent observation window and is flagged when the probability the model assigns that sequence drops beyond a threshold.

A collection of small standalone hardware modules, each modeling a familiar building block of a digital system and each independent of the others, shipping synthesizable source, a testbench and a waveform of the result. The set covers a multiply-accumulate unit that folds signed 8-bit products into a 20-bit accumulator, a four-deep FIFO queue of 16-bit words, an 8-bit shift register loadable in parallel or fed serially, a four-entry LIFO stack with full and empty flags, and a simple cryptographer that applies a right shift or a summation through a 16-bit full adder for K rounds.

A special-purpose processor that computes the greatest common divisor and the least common multiple of two numbers, choosing between them from an input opcode. The design splits into the two classical halves, synchronized on the system clock: a datapath holding the registers, multiplexers, ALU and comparator, whose values update according to the next state, and a controller whose three-state machine derives that next state from the comparator outputs. Written in Verilog, verified against a testbench waveform, then synthesized and programmed onto an Altera DE2-115 board carrying a Cyclone IV EP4CE115 device.

Sudoku asks for a 9×9 grid filled so that every row, every column and each of the nine 3×3 blocks holds the digits 1 to 9 exactly once; the multiple variant stacks several grids that overlap, and the shared cells have to satisfy every grid they belong to at once. This Prolog solver handles both through constraint logic programming over finite domains: rather than searching the grid cell by cell, it states the rules of the puzzle as constraints and lets propagation narrow the candidates before a search assigns the rest. The overlapping version needs no new rules — the five grids simply share variables wherever they meet.

Musical genres are human labels resting on shared instrumentation, rhythmic structure and harmonic content, and annotating them by hand does not scale to the collections that music information retrieval systems have to index. This Python pipeline reduces every track to a compact numeric summary with librosa: spectral centroid, bandwidth, contrast, roll-off and flux, zero crossing rate, tempo, 13 MFCCs, 12 chroma bins, 10 mel-scale bands and 6 tonal centroid coordinates, each taken as a mean and standard deviation over the frames of the signal. The scaled vectors then train a support vector machine, with random forest, MLP and k-nearest neighbours left in as alternatives.

An AVL tree, named after its inventors Adelson-Velsky and Landis, was the first self-balancing binary search tree to be invented: the heights of any node’s two child subtrees differ by at most one, and whenever an insertion or a deletion breaks that property the tree restores it with one or more rotations. Staying balanced is what keeps lookup, insertion and deletion at O(log n) in both the average and the worst case. This is a self-contained Java implementation with no external dependencies, supporting insertion, deletion, search and depth queries through the four standard rotation cases, plus in-order and pre-order traversals.