the `geo` mini-library

// ============================================================================
//  starter/geo.cpp  —  the IMPLEMENTATION of the geo library   (STARTER)
// ----------------------------------------------------------------------------
//  This is the file you edit. The header geo.h already DECLARED these five
//  functions; here you DEFINE them (write the bodies). Each one sits inside
//  `namespace geo { ... }` so its full name matches the declaration in the
//  header — geo::rectangleArea, geo::hypotenuse, and so on.
//
//  Fill in the five TASK blocks. Build / grade with:
//      make build   compile the starter (it already compiles)
//      make test    run the unit tests  ->  RED until you finish the tasks
//      make solution / make test-solution   the reference, for when you're stuck
//
//  WHY each stub currently returns a wrong-but-compiling placeholder: a value-
//  returning function must return a value on every path (2.2) — running off the
//  end is undefined behavior. The placeholders keep the file compiling and
//  warning-clean so your FIRST `make test` is a clean RED, not a build error.
//  Replacing them with the real formulas turns that red into green.
// ============================================================================

#include "geo.h"   // 2.11 best practice: a .cpp #includes its OWN paired header
                    // so the compiler checks your bodies against the contract.
#include <cmath>    // std::sqrt — you will need it for the hypotenuse.

namespace geo
{
    // ─── TASK 1: rectangleArea ─────────────────────────────────────────────
    // Return the area of a width x height rectangle: width * height.
    // Both parameters are int; the product is int. Easiest one — warm up.
    //
    //   >>> YOUR CODE HERE <<<
    int rectangleArea(int width, int height)
    {
        return width + height;   // placeholder: wrong (should be *, not +),
                                 // but compiles warning-clean. Replace it.
    }
    // ───────────────────────────────────────────────────────────────────────

    // ─── TASK 2: rectanglePerimeter ────────────────────────────────────────
    // Return the perimeter (the distance around all four sides):
    //   2 * width + 2 * height.
    //
    //   >>> YOUR CODE HERE <<<
    int rectanglePerimeter(int width, int height)
    {
        return width + height;  // placeholder: wrong (forgets the other two
                                // sides), but compiles warning-clean. Replace it.
    }
    // ───────────────────────────────────────────────────────────────────────

    // ─── TASK 3: rightTriangleArea ─────────────────────────────────────────
    // Return HALF the bounding rectangle's area: (a * b) / 2.
    // Watch the types: a and b are int, but you must return a double, and for
    // an ODD product (e.g. 3 * 5 = 15) the answer is 7.5, NOT 7. Make the
    // division happen in floating point — for example divide by 2.0, so the
    // fractional half is kept instead of being chopped off by integer division.
    //
    //   >>> YOUR CODE HERE <<<
    double rightTriangleArea(int a, int b)
    {
        return a + b;   // placeholder
    }
    // ───────────────────────────────────────────────────────────────────────

    // ─── TASK 4: hypotenuse ────────────────────────────────────────────────
    // Return the length of the long slanted side by the Pythagorean theorem:
    //   c = square_root(a*a + b*b).
    // Use std::sqrt (from <cmath>, already included above). a*a + b*b is an int
    // expression; std::sqrt takes/returns a double, so the result comes back as
    // a double automatically.
    //
    //   >>> YOUR CODE HERE <<<
    double hypotenuse(int a, int b)
    {
        return a + b;   // placeholder
    }
    // ───────────────────────────────────────────────────────────────────────

    // ─── TASK 5: rectangleDiagonal  (the stretch — COMPOSE, don't re-derive) ─
    // The diagonal of a width x height rectangle is the hypotenuse of the right
    // triangle whose two legs ARE the rectangle's sides. So DON'T call std::sqrt
    // again here — CALL the geo::hypotenuse function you just wrote, passing the
    // width and height as its two legs, and return whatever it gives you. This
    // is one of your own functions calling another (2.1 / 2.6). Because both
    // live in `namespace geo`, you can call it as just hypotenuse(width, height)
    // from in here (no geo:: prefix needed inside the namespace).
    //
    //   >>> YOUR CODE HERE <<<
    double rectangleDiagonal(int width, int height)
    {
        return width + height;  // placeholder
    }
    // ───────────────────────────────────────────────────────────────────────
}

// ============================================================================
//  solution/geo.cpp  —  reference IMPLEMENTATION of the geo library
// ----------------------------------------------------------------------------
//  One correct, warning-clean way to write the five bodies. Peek only after you
//  have tried your own — you learn the .h/.cpp split by getting YOUR version to
//  pass `make test` first.
//
//  Notice the shape: same #include of the paired header, same `namespace geo`
//  wrapper, and the bodies match the prototypes in geo.h exactly. This Foo.h /
//  Foo.cpp pairing is the template for every LLVM pass you will write later.
// ============================================================================

#include "geo.h"   // include our own paired header (2.11) — compile-time check
#include <cmath>   // std::sqrt

namespace geo
{
    // TASK 1 — both ints, product is int.
    int rectangleArea(int width, int height)
    {
        return width * height;
    }

    // TASK 2 — all four sides: two widths + two heights.
    int rectanglePerimeter(int width, int height)
    {
        return 2 * width + 2 * height;
    }

    // TASK 3 — divide by 2.0 (a double literal) so the division is done in
    // floating point and the ".5" on odd products survives. Writing `/ 2`
    // instead would truncate (15/2 == 7) before the double conversion — a
    // classic integer-division bug.
    double rightTriangleArea(int a, int b)
    {
        return (a * b) / 2.0;
    }

    // TASK 4 — Pythagoras. a*a + b*b is an int; std::sqrt promotes it to double
    // and returns a double.
    double hypotenuse(int a, int b)
    {
        return std::sqrt(a * a + b * b);
    }

    // TASK 5 — COMPOSITION: the diagonal IS the hypotenuse of the triangle made
    // by the rectangle's two sides. Reuse the function above instead of redoing
    // the square-root math (DRY, 2.2 / 2.6). Inside namespace geo we can call it
    // unqualified as hypotenuse(...).
    double rectangleDiagonal(int width, int height)
    {
        return hypotenuse(width, height);
    }
}

// ============================================================================
//  tests/tests.cpp  —  the automated grader for the geo library  (Chapter 2)
// ----------------------------------------------------------------------------
//  This is a CONSUMER of your library: like a tiny main(), it #includes the
//  header (the contract) and calls the API through the geo:: namespace. It does
//  NOT include any .cpp — the Makefile compiles this file together with EITHER
//  starter/geo.cpp (the `make test` target) OR solution/geo.cpp (the
//  `make test-solution` target) and lets the LINKER join the call to its
//  definition (2.8). That separation — declarations here, definition compiled
//  in separately — is the whole point of the chapter.
//
//  Tiny no-framework harness: CHECK fails loudly with the line number; the
//  program's EXIT CODE (0 = all good, 1 = something failed) is what `make`
//  turns into PASS / FAIL.
// ============================================================================

#include <iostream>
#include <cmath>        // std::abs for the floating-point comparison
#include "geo.h"        // the library's public interface (declarations only).
                        // Found via the -I. include path set in the Makefile.

static int fails = 0;

// Exact-equality check — for the int-returning functions, where == is correct.
#define CHECK(cond) \
    do { if(!(cond)){ std::cerr << "FAIL: " #cond "  @line " << __LINE__ << "\n"; ++fails; } } while(0)

// Floating-point check — doubles can carry tiny rounding dust, so compare
// "close enough" rather than bit-for-bit. (You'll formalize float comparison in
// Chapter 6; a small fixed epsilon is plenty for these whole-number answers.)
#define CHECK_NEAR(got, want) \
    do { double g_=(got), w_=(want); if(std::abs(g_ - w_) > 1e-9){ \
        std::cerr << "FAIL: " #got " == " #want "  (got " << g_ << ", want " << w_ \
                  << ")  @line " << __LINE__ << "\n"; ++fails; } } while(0)

int main()
{
    // ── geo::rectangleArea ────────────────────────────────────────────────
    CHECK(geo::rectangleArea(3, 4) == 12);
    CHECK(geo::rectangleArea(7, 1) == 7);
    CHECK(geo::rectangleArea(10, 10) == 100);
    CHECK(geo::rectangleArea(0, 5) == 0);     // edge case: zero-width → zero area

    // ── geo::rectanglePerimeter ───────────────────────────────────────────
    CHECK(geo::rectanglePerimeter(3, 4) == 14);    // 2*3 + 2*4
    CHECK(geo::rectanglePerimeter(5, 5) == 20);    // square
    CHECK(geo::rectanglePerimeter(0, 6) == 12);    // edge case: degenerate side

    // ── geo::rightTriangleArea ────────────────────────────────────────────
    CHECK_NEAR(geo::rightTriangleArea(3, 4), 6.0);    // even product → whole
    CHECK_NEAR(geo::rightTriangleArea(6, 8), 24.0);
    CHECK_NEAR(geo::rightTriangleArea(3, 5), 7.5);    // EDGE: odd product must be
                                                      // 7.5, not 7 — this is the
                                                      // integer-division trap.

    // ── geo::hypotenuse ───────────────────────────────────────────────────
    // Pythagorean triples chosen so the answers are exact whole numbers.
    CHECK_NEAR(geo::hypotenuse(3, 4), 5.0);
    CHECK_NEAR(geo::hypotenuse(5, 12), 13.0);
    CHECK_NEAR(geo::hypotenuse(6, 8), 10.0);

    // ── geo::rectangleDiagonal  (must REUSE geo::hypotenuse) ──────────────
    CHECK_NEAR(geo::rectangleDiagonal(3, 4), 5.0);     // same 3-4-5 triangle
    CHECK_NEAR(geo::rectangleDiagonal(8, 6), 10.0);    // legs swapped: still 10
    // Cross-check the composition: the diagonal of a w x h rectangle MUST equal
    // hypotenuse(w, h). If Task 5 re-derived the math wrong, this still catches
    // it; if it correctly delegates, the two are equal by construction.
    CHECK_NEAR(geo::rectangleDiagonal(5, 12), geo::hypotenuse(5, 12));

    if (!fails) std::cout << "PASS ✅  all geo checks passed.\n";
    else        std::cout << "FAIL ❌  " << fails << " check(s) failed — see lines above.\n";
    return fails ? 1 : 0;
}

// ============================================================================
//  demo.cpp  —  a tiny program that USES the geo library  (provided, complete)
// ----------------------------------------------------------------------------
//  This is the "application" side. It knows NOTHING about how the geo functions
//  work — it only #includes the header (the contract) and calls the API through
//  the geo:: qualifier. The actual code that runs comes from whichever geo.cpp
//  the Makefile links in (starter/ for `make run`, solution/ for `make solution`).
//
//  You don't have to edit this file. Run it with `make run` to watch your
//  library in action: while your bodies are still stubs the numbers are wrong,
//  and they become correct as you finish each task. (`make test` is the real
//  grader; this is just a friendly demonstration.)
// ============================================================================

#include <iostream>
#include "geo.h"        // declarations only — the library's public interface

int main()
{
    // A 3 x 4 rectangle is the running example (its diagonal closes a 3-4-5
    // right triangle, so every number below is clean).
    int w { 3 };
    int h { 4 };

    std::cout << "geo demo — rectangle " << w << " x " << h << "\n";
    std::cout << "  area:       " << geo::rectangleArea(w, h)       << "\n";
    std::cout << "  perimeter:  " << geo::rectanglePerimeter(w, h)  << "\n";
    std::cout << "  diagonal:   " << geo::rectangleDiagonal(w, h)   << "\n";

    std::cout << "right triangle with legs " << w << " and " << h << "\n";
    std::cout << "  area:       " << geo::rightTriangleArea(w, h)   << "\n";
    std::cout << "  hypotenuse: " << geo::hypotenuse(w, h)          << "\n";

    return 0;
}

// ============================================================================
//  geo.h  —  the PUBLIC INTERFACE of the geo mini-library  (Chapter 2)
// ----------------------------------------------------------------------------
//  This header is COMPLETE and PROVIDED. You do not edit it. Read it closely —
//  a header is a contract. It tells every other file *what functions exist*,
//  *what they take*, and *what they return*, WITHOUT revealing how they work.
//  The bodies (the "how") live in a separate .cpp file that you implement.
//
//  Three Chapter-2 ideas are on display in this one little file:
//
//    1) HEADER GUARD  — the #ifndef / #define / #endif sandwich below stops the
//       file's contents from being pasted in twice if it gets #included more
//       than once in the same translation unit (2.12). The guard macro is the
//       FILENAME IN ALL CAPS with punctuation turned into underscores: GEO_H.
//
//    2) NAMESPACE     — every name lives inside `namespace geo { ... }` (2.9),
//       so you call them as geo::rectangleArea(...). The qualifier keeps these
//       names from colliding with anyone else's `area` or `perimeter`.
//
//    3) DECLARATIONS ONLY — a header holds forward declarations (prototypes):
//       return type, name, parameter types, semicolon, NO body (2.7, 2.11).
//       Putting a *definition* here would break the moment two .cpp files
//       included it (an ODR / "duplicate definition" linker error).
//
//  CS6340 / LLVM lens: every LLVM pass you will write looks exactly like this —
//  a `Foo.h` that declares an API inside a namespace behind a header guard, and
//  a `Foo.cpp` that defines the bodies. You are building that muscle now.
// ============================================================================

#ifndef GEO_H              // if GEO_H has not been defined yet...
#define GEO_H              // ...define it now, so a 2nd include skips the body

namespace geo              // a named scope region: everything here is geo::name
{
    // ── Rectangles (use int — whole-number sides) ──────────────────────────
    //
    // area = width * height.  Returns the enclosed area.
    int rectangleArea(int width, int height);

    // perimeter = twice the width plus twice the height (all four sides).
    int rectanglePerimeter(int width, int height);

    // ── Right triangles (use int legs; the hypotenuse may be fractional) ───
    //
    // A right triangle has two perpendicular "legs" a and b meeting at the
    // square corner. Its area is half of the bounding rectangle: (a * b) / 2.
    // Returns a double because halving an odd product is not a whole number.
    double rightTriangleArea(int a, int b);

    // The hypotenuse is the long slanted side, by the Pythagorean theorem:
    //   c = square_root(a*a + b*b).
    // Returns a double (square roots are rarely whole numbers).
    double hypotenuse(int a, int b);

    // ── Composition: a function built FROM the functions above ─────────────
    //
    // The straight-line diagonal of a width x height rectangle is the
    // hypotenuse of the right triangle whose legs are the rectangle's sides.
    // Implement this by REUSING geo::hypotenuse — do not re-derive the math.
    // (This is the "functions call functions" idea made physical, 2.1 / 2.6.)
    double rectangleDiagonal(int width, int height);
}

#endif // GEO_H

# Chapter 2 — geo mini-library · unit-test grader.
# Targets follow the drills/CLAUDE.md Makefile contract. (Recipes use TABS.)
#
# Multi-file build (the point of the chapter): the program/grader is compiled
# from TWO .cpp files at once — a consumer (demo.cpp or tests/tests.cpp) plus an
# implementation (starter/geo.cpp or solution/geo.cpp). geo.h is included by all
# of them; it is never compiled on its own.

CXX      := clang++
# -I. puts the chapter root on the include path, so every file can write the
# paired-header include by its simple name: #include "geo.h" (matches the 2.11
# add.h/add.cpp convention, and how real projects — and LLVM — find headers).
CXXFLAGS := -std=c++17 -Wall -Wextra -I.

.PHONY: all build run test solution test-solution clean

all: build

# ── Starter: link demo.cpp against the LEARNER's starter/geo.cpp ────────────
build: starter/app
starter/app: demo.cpp geo.h starter/geo.cpp
	$(CXX) $(CXXFLAGS) demo.cpp starter/geo.cpp -o starter/app

run: build
	./starter/app

# ── The grader: compile the tests with the LEARNER's starter/geo.cpp ───────
# RED until the TASK blocks are filled in; GREEN once they are.
test: tests/tests.cpp geo.h starter/geo.cpp
	@$(CXX) $(CXXFLAGS) tests/tests.cpp starter/geo.cpp -o tests/run
	@./tests/run || echo "FAIL ❌  fill in the TASK blocks in starter/geo.cpp until every check passes."

# ── The reference solution, built + run as a program ───────────────────────
solution: solution/app
	./solution/app
solution/app: demo.cpp geo.h solution/geo.cpp
	$(CXX) $(CXXFLAGS) demo.cpp solution/geo.cpp -o solution/app

# ── Proof the exercise is solvable: tests + solution/geo.cpp MUST be green ──
test-solution: tests/tests.cpp geo.h solution/geo.cpp
	@$(CXX) $(CXXFLAGS) tests/tests.cpp solution/geo.cpp -o tests/run
	@./tests/run

clean:
	rm -f starter/app solution/app tests/run