Skip to content

brycewang-stanford/Auto-Empirical-Research-Skills / skills/35-bahayonghang-academic-writing-skills/skills/latex-paper-en

latex-paper-en

Verified

English LaTeX academic paper assistant for existing `.tex` projects. Use this skill whenever the user wants to compile, lint, audit, or improve an English LaTeX conference or journal paper such as IEEE, ACM, Springer, NeurIPS, or ICML submissions. Trigger even when the user only mentions one paper issue, such as bibliography errors, grammar cleanup, sentence splitting, logic review, expression polishing, translation, title optimization, figure checks, pseudocode review, algorithm block cleanup, de-AI editing, experiment-section review, table structure validation, three-line table generation, abstract structure diagnosis, or journal adaptation. Also trigger for "proofread my paper", "fix my LaTeX", "prepare for submission", "check my manuscript", "improve my writing", "three-line table", "booktabs", "check abstract", "reformat for another journal", "换投", `algorithm2e`, `algorithmicx`, `algpseudocodex`, `Require/Ensure`, or "Algorithm 1" when the user has a .tex file.

FileKindSize
SKILL.mdskill md8.5 KB
agents/openai.yamlconfig390 B
evals/evals.jsonconfig7.8 KB
examples/compile-and-bibliography.mdmarkdown551 B
examples/experiment-review.mdmarkdown527 B
examples/figures-and-title.mdmarkdown513 B
examples/grammar-and-logic.mdmarkdown687 B
examples/translation-and-deai.mdmarkdown630 B
references/ABSTRACT_STRUCTURE.mdmarkdown4.9 KB
references/BEST_PRACTICES.mdmarkdown456 B
references/CITATION_STYLES.mdmarkdown4.2 KB
references/CITATION_VERIFICATION.mdmarkdown4.1 KB
references/COMMON_ERRORS.mdmarkdown2.8 KB
references/COMPILATION.mdmarkdown2.0 KB
references/DEAI_GUIDE.mdmarkdown16.8 KB
references/FORBIDDEN_TERMS.mdmarkdown1.6 KB
references/JOURNAL_ABBREVIATIONS.mdmarkdown3.5 KB
references/JOURNAL_ADAPTATION_WORKFLOW.mdmarkdown3.6 KB
references/NUMBER_UNIT_GUIDE.mdmarkdown2.3 KB
references/REVIEWER_PERSPECTIVE.mdmarkdown4.9 KB
references/STYLE_GUIDE.mdmarkdown6.5 KB
references/TABLE_GUIDE.mdmarkdown3.7 KB
references/TERMINOLOGY.mdmarkdown9.9 KB
references/TRANSLATION_GUIDE.mdmarkdown11.4 KB
references/VENUES.mdmarkdown6.4 KB
references/WRITING_PHILOSOPHY.mdmarkdown6.7 KB
references/modules/ABSTRACT.mdmarkdown1.2 KB
references/modules/ADAPT.mdmarkdown1.3 KB
references/modules/BIBLIOGRAPHY.mdmarkdown1.3 KB
references/modules/CAPTION.mdmarkdown2.0 KB
references/modules/COMPILE.mdmarkdown2.8 KB
references/modules/DEAI.mdmarkdown1.0 KB
references/modules/EXPERIMENT.mdmarkdown3.8 KB
references/modules/EXPRESSION.mdmarkdown789 B
references/modules/FORMAT.mdmarkdown440 B
references/modules/GRAMMAR.mdmarkdown980 B
references/modules/LOGIC.mdmarkdown7.6 KB
references/modules/PSEUDOCODE.mdmarkdown1.7 KB
references/modules/SENTENCES.mdmarkdown575 B
references/modules/TABLES.mdmarkdown1.3 KB
references/modules/TITLE.mdmarkdown7.7 KB
references/modules/TRANSLATION.mdmarkdown1.1 KB
references/modules/WORKFLOW.mdmarkdown910 B
scripts/analyze_abstract.pyscript17.3 KB
scripts/analyze_experiment.pyscript18.1 KB
scripts/analyze_grammar.pyscript3.6 KB
scripts/analyze_logic.pyscript18.4 KB
scripts/analyze_sentences.pyscript3.6 KB
scripts/check_figures.pyscript6.4 KB
scripts/check_format.pyscript6.4 KB
scripts/check_pseudocode.pyscript11.2 KB
scripts/check_references.pyscript14.2 KB
scripts/check_tables.pyscript16.3 KB
scripts/compile.pyscript17.4 KB
scripts/deai_batch.pyscript9.9 KB
scripts/deai_check.pyscript16.4 KB
scripts/extract_prose.pyscript2.7 KB
scripts/generate_table.pyscript8.8 KB
scripts/improve_expression.pyscript3.2 KB
scripts/online_bib_verify.pyscript11.9 KB
scripts/optimize_title.pyscript15.4 KB
scripts/parsers.pyscript14.9 KB
scripts/translate_academic.pyscript5.1 KB
scripts/verify_bib.pyscript18.9 KB

scripts/generate_table.py

View on GitHub
#!/usr/bin/env python3
"""
Table Generator - Convert structured data to publication-ready table code.

Usage:
    uv run python -B generate_table.py data.csv --style booktabs
    uv run python -B generate_table.py data.json --style booktabs --bilingual
    uv run python -B generate_table.py data.csv --style booktabs --stats
"""

import argparse
import csv
import json
import sys
from io import StringIO
from pathlib import Path


class TableGenerator:
    """Generate LaTeX booktabs and Markdown tables from structured data."""

    def __init__(self, style: str = "booktabs"):
        self.style = style

    def generate(
        self,
        headers: list[str],
        rows: list[list[str]],
        bilingual: bool = False,
        stats: bool = False,
        caption_en: str = "",
        caption_zh: str = "",
    ) -> dict:
        """Generate table in multiple formats.

        Returns dict with keys: markdown, latex, captions, word_tip.
        """
        result = {
            "markdown": self._to_markdown(headers, rows),
            "latex": self._to_latex(headers, rows, caption_en),
            "word_tip": (
                "To create a three-line table in Word:\n"
                "1. Insert a standard table\n"
                "2. Select all → Borders → No Border\n"
                "3. Select header row → add bottom border\n"
                "4. Select entire table → add top and bottom borders\n"
                "Result: a clean three-line table."
            ),
        }

        if bilingual:
            result["captions"] = self._suggest_captions(headers, caption_en, caption_zh)
        if stats:
            result["stats_note"] = (
                "\\begin{tablenotes}\n"
                "  \\small\n"
                "  \\item Note. Bold values indicate best performance.\n"
                "  \\item * $p < 0.05$; ** $p < 0.01$; *** $p < 0.001$.\n"
                "\\end{tablenotes}"
            )

        return result

    def _to_markdown(self, headers: list[str], rows: list[list[str]]) -> str:
        """Generate Markdown three-line table."""
        if not headers:
            return ""

        # Calculate column widths
        col_widths = [len(h) for h in headers]
        for row in rows:
            for i, cell in enumerate(row):
                if i < len(col_widths):
                    col_widths[i] = max(col_widths[i], len(cell))

        # Build table
        lines = []

        # Header
        header_cells = [h.ljust(col_widths[i]) for i, h in enumerate(headers)]
        lines.append("| " + " | ".join(header_cells) + " |")

        # Separator (represents the mid-rule)
        sep_cells = ["-" * col_widths[i] for i in range(len(headers))]
        lines.append("| " + " | ".join(sep_cells) + " |")

        # Data rows
        for row in rows:
            padded = []
            for i in range(len(headers)):
                cell = row[i] if i < len(row) else ""
                padded.append(cell.ljust(col_widths[i]))
            lines.append("| " + " | ".join(padded) + " |")

        return "\n".join(lines)

    def _to_latex(self, headers: list[str], rows: list[list[str]], caption: str = "") -> str:
        """Generate LaTeX booktabs table code."""
        n_cols = len(headers)
        if n_cols == 0:
            return ""

        # Detect numeric columns for S column type
        col_types = []
        for i in range(n_cols):
            is_numeric = True
            for row in rows:
                if i < len(row):
                    cell = row[i].strip().rstrip("*").replace("\\textbf{", "").rstrip("}")
                    try:
                        float(cell.replace(",", ""))
                    except ValueError:
                        if cell and cell not in ("-", "--", "N/A", "n/a"):
                            is_numeric = False
                            break
            col_types.append("S" if is_numeric and i > 0 else "l")

        col_spec = "".join(col_types)

        lines = []
        lines.append("\\begin{table}[t]")
        if caption:
            lines.append(f"  \\caption{{{caption}}}")
            # Generate a simple label from caption
            label = caption.lower()
            label = label.replace(" ", "_")[:30]
            label = "".join(c for c in label if c.isalnum() or c == "_")
            lines.append(f"  \\label{{tab:{label}}}")
        lines.append("  \\centering")
        lines.append(f"  \\begin{{tabular}}{{{col_spec}}}")
        lines.append("    \\toprule")

        # Headers (wrap in braces for S columns)
        header_cells = []
        for i, h in enumerate(headers):
            if col_types[i] == "S":
                header_cells.append("{" + h + "}")
            else:
                header_cells.append(h)
        lines.append("    " + " & ".join(header_cells) + " \\\\")
        lines.append("    \\midrule")

        # Data rows
        for row in rows:
            padded = []
            for i in range(n_cols):
                cell = row[i] if i < len(row) else ""
                padded.append(cell)
            lines.append("    " + " & ".join(padded) + " \\\\")

        lines.append("    \\bottomrule")
        lines.append("  \\end{tabular}")
        lines.append("\\end{table}")

        return "\n".join(lines)

    def _suggest_captions(self, headers: list[str], caption_en: str, caption_zh: str) -> dict:
        """Suggest bilingual captions based on column content."""
        suggestion = {
            "en": caption_en or f"Comparison of {', '.join(headers[1:3])} across methods.",
            "zh": caption_zh or f"不同方法的{'、'.join(headers[1:3])}比较。",
        }
        return suggestion


def load_csv(file_path: str) -> tuple[list[str], list[list[str]]]:
    """Load data from CSV file."""
    path = Path(file_path)
    content = path.read_text(encoding="utf-8", errors="replace")
    reader = csv.reader(StringIO(content))
    all_rows = list(reader)
    if not all_rows:
        return [], []
    return all_rows[0], all_rows[1:]


def load_json(file_path: str) -> tuple[list[str], list[list[str]]]:
    """Load data from JSON file.

    Expected format:
    {
        "headers": ["Model", "Accuracy", "F1"],
        "rows": [["Baseline", "85.3", "83.7"], ...]
    }
    """
    path = Path(file_path)
    data = json.loads(path.read_text(encoding="utf-8"))
    return data.get("headers", []), data.get("rows", [])


def main():
    parser = argparse.ArgumentParser(description="Table Generator - CSV/JSON to LaTeX booktabs")
    parser.add_argument("data_file", help="CSV or JSON file with table data")
    parser.add_argument(
        "--style",
        choices=["booktabs", "plain"],
        default="booktabs",
        help="Table style (default: booktabs)",
    )
    parser.add_argument(
        "--bilingual", "-b", action="store_true", help="Generate bilingual captions"
    )
    parser.add_argument(
        "--stats", "-s", action="store_true", help="Add statistical significance note"
    )
    parser.add_argument("--caption-en", default="", help="English caption text")
    parser.add_argument("--caption-zh", default="", help="Chinese caption text")
    parser.add_argument("--json", "-j", action="store_true", help="Output in JSON format")

    args = parser.parse_args()

    data_path = Path(args.data_file)
    if not data_path.exists():
        print(f"[ERROR] File not found: {args.data_file}")
        sys.exit(1)

    # Load data
    if data_path.suffix.lower() == ".json":
        headers, rows = load_json(args.data_file)
    else:
        headers, rows = load_csv(args.data_file)

    if not headers:
        print("[ERROR] No data found in file")
        sys.exit(1)

    # Generate
    gen = TableGenerator(style=args.style)
    result = gen.generate(
        headers,
        rows,
        bilingual=args.bilingual,
        stats=args.stats,
        caption_en=args.caption_en,
        caption_zh=args.caption_zh,
    )

    if args.json:
        print(json.dumps(result, indent=2, ensure_ascii=False))
    else:
        print("=" * 60)
        print("Markdown Preview")
        print("=" * 60)
        print(result["markdown"])
        print()
        print("=" * 60)
        print("LaTeX Code (booktabs)")
        print("=" * 60)
        print(result["latex"])
        if result.get("captions"):
            print()
            print("=" * 60)
            print("Bilingual Captions")
            print("=" * 60)
            print(f"EN: {result['captions']['en']}")
            print(f"ZH: {result['captions']['zh']}")
        if result.get("stats_note"):
            print()
            print("=" * 60)
            print("Statistical Note (add inside threeparttable)")
            print("=" * 60)
            print(result["stats_note"])
        print()
        print("=" * 60)
        print("Word Tip")
        print("=" * 60)
        print(result["word_tip"])

    sys.exit(0)


if __name__ == "__main__":
    main()
rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.Stars: 196kUpdated Claude CodeCodexVerifiedInstall