Degree Symbol with Slash (°/): Complete Technical Guide

# Degree symbol with slash in Python
import math

def calculate_slope(angle_per_meter, distance):
    """Calculate total angle change over distance"""
    total_angle = angle_per_meter * distance
    return f"Total angle: {total_angle}\u00B0"

def angular_velocity(degrees_per_second, time_seconds):
    """Calculate angular displacement"""
    total_degrees = degrees_per_second * time_seconds
    return f"Rotation: {total_degrees}\u00B0 in {time_seconds}s"

def temperature_gradient(celsius_per_km, altitude_km):
    """Calculate temperature change with altitude"""
    temp_change = celsius_per_km * altitude_km
    return f"Temperature change: {temp_change}\u00B0C"

# Example usage
gradient = 2.5  # degrees per meter
distance = 10   # meters
result = calculate_slope(gradient, distance)
print(f"{result} over {distance}m")
print(f"Rate: {gradient}\u00B0/m")

# Angular velocity example
angular_speed = 15  # degrees per second
duration = 5       # seconds
print(angular_velocity(angular_speed, duration))
print(f"Rate: {angular_speed}\u00B0/s")

# Temperature gradient example
temp_gradient = -6.5  # degrees per km
altitude = 2.0        # km
print(temperature_gradient(temp_gradient, altitude))
print(f"Lapse rate: {temp_gradient}\u00B0/km")

// Degree symbol with slash in JavaScript
class TechnicalCalculator {
    // Angular velocity calculations
    static calculateAngularVelocity(degreesPerSecond, time) {
        const totalDegrees = degreesPerSecond * time;
        return {
            total: totalDegrees,
            rate: degreesPerSecond,
            unit: '\u00B0/s',
            result: `Total rotation: ${totalDegrees}\u00B0 in ${time}s`
        };
    }

    // Slope calculations
    static calculateSlope(degreesPerMeter, distance) {
        const totalAngle = degreesPerMeter * distance;
        return {
            angle: totalAngle,
            gradient: degreesPerMeter,
            unit: '\u00B0/m',
            result: `Slope: ${degreesPerMeter}\u00B0/m over ${distance}m = ${totalAngle}\u00B0`
        };
    }

    // Temperature gradient
    static calculateTemperatureGradient(celsiusPerKm, altitude) {
        const tempChange = celsiusPerKm * altitude;
        return {
            change: tempChange,
            gradient: celsiusPerKm,
            unit: '\u00B0/km',
            result: `Temperature change: ${tempChange}\u00B0C at ${altitude}km altitude`
        };
    }
}

// Usage examples
const angularCalc = TechnicalCalculator.calculateAngularVelocity(15, 5);
console.log(angularCalc.result);
console.log(`Rate: ${angularCalc.rate}${angularCalc.unit}`);

const slopeCalc = TechnicalCalculator.calculateSlope(2.5, 10);
console.log(slopeCalc.result);

const tempCalc = TechnicalCalculator.calculateTemperatureGradient(-6.5, 2);
console.log(tempCalc.result);

// Display in HTML
document.getElementById('result').innerHTML =
    `${angularCalc.result}
${slopeCalc.result}
${tempCalc.result}`;

<!-- HTML entities for degree symbol with slash -->
<div class="technical-specs">
    <h4>Engineering Specifications</h4>
    <p>Slope: 5&deg;/m (5 degrees per meter)</p>
    <p>Angular velocity: 30&#176;/s</p>
    <p>Temperature gradient: 6.5&#x00B0;/km</p>
</div>

<!-- Using Unicode directly -->
<section class="measurements">
    <h3>Technical Measurements</h3>
    <ul>
        <li>Road grade: 3°/m</li>
        <li>Pipe inclination: 1°/ft</li>
        <li>Rotation rate: 180°/s</li>
        <li>Thermal gradient: 2°/cm</li>
        <li>Precession rate: 0.5°/h</li>
    </ul>
</section>

<!-- Form inputs for technical calculations -->
<form id="calculator">
    <label for="gradient">Slope Gradient (°/m):</label>
    <input type="number" id="gradient" step="0.1" value="2.5">

    <label for="distance">Distance (m):</label>
    <input type="number" id="distance" step="0.1" value="10">

    <button type="button" onclick="calculate()">
        Calculate Total Angle
    </button>

    <div id="result"></div>
</form>

/* CSS content property for degree symbol with slash */
.slope-unit::after {
    content: "°/m";
    color: #2563eb;
    font-weight: 600;
}

.angular-rate::after {
    content: "°/s";
    color: #059669;
}

.temp-gradient::before {
    content: "\00B0/";
    color: #dc2626;
}

/* Custom properties for technical units */
:root {
    --degree-slash: "°/";
    --degree-per-meter: "°/m";
    --degree-per-second: "°/s";
    --degree-per-kilometer: "°/km";
}

/* Usage in pseudo-elements */
.measurement::after {
    content: var(--degree-per-meter);
}

.technical-spec {
    font-family: 'Courier New', monospace;
    background: #f3f4f6;
    padding: 0.25rem 0.5rem;
    border-radius: 0.25rem;
    border-left: 3px solid #3b82f6;
}

/* Data attributes display */
[data-unit="°/m"]::after {
    content: attr(data-unit);
    font-weight: bold;
    color: #1f2937;
}

#include <iostream>
#include <string>
#include <cmath>

class TechnicalUnit {
private:
    double value;
    std::string unit;

public:
    TechnicalUnit(double v, std::string u) : value(v), unit(u) {}

    std::string toString() const {
        return std::to_string(value) + unit;
    }

    // Angular velocity calculations
    static TechnicalUnit calculateAngularVelocity(double degreesPerSec, double timeSec) {
        double totalDegrees = degreesPerSec * timeSec;
        return TechnicalUnit(totalDegrees, "\u00B0");
    }

    // Slope calculations
    static TechnicalUnit calculateSlope(double degreesPerMeter, double distance) {
        double totalAngle = degreesPerMeter * distance;
        return TechnicalUnit(totalAngle, "\u00B0");
    }
};

int main() {
    // Angular velocity example
    double angularSpeed = 15.0; // degrees per second
    double duration = 5.0;      // seconds

    auto rotation = TechnicalUnit::calculateAngularVelocity(angularSpeed, duration);
    std::cout << "Total rotation: " << rotation.toString()
              << " in " << duration << "s" << std::endl;
    std::cout << "Rate: " << angularSpeed << "\u00B0/s" << std::endl;

    // Slope calculation example
    double gradient = 2.5;  // degrees per meter
    double distance = 10.0; // meters

    auto slope = TechnicalUnit::calculateSlope(gradient, distance);
    std::cout << "Slope: " << gradient << "\u00B0/m over "
              << distance << "m = " << slope.toString() << std::endl;

    return 0;
}

public class TechnicalCalculations {

    // Constants for degree symbols
    public static final String DEGREE_SYMBOL = "\u00B0";
    public static final String DEGREE_PER_METER = "\u00B0/m";
    public static final String DEGREE_PER_SECOND = "\u00B0/s";
    public static final String DEGREE_PER_KILOMETER = "\u00B0/km";

    public static class AngularMeasurement {
        private double value;
        private String unit;

        public AngularMeasurement(double value, String unit) {
            this.value = value;
            this.unit = unit;
        }

        public String toString() {
            return String.format("%.2f%s", value, unit);
        }

        public double getValue() { return value; }
        public String getUnit() { return unit; }
    }

    // Calculate angular velocity
    public static AngularMeasurement calculateAngularVelocity(
            double degreesPerSecond, double timeSeconds) {
        double totalDegrees = degreesPerSecond * timeSeconds;
        return new AngularMeasurement(totalDegrees, DEGREE_SYMBOL);
    }

    // Calculate slope
    public static AngularMeasurement calculateSlope(
            double degreesPerMeter, double distance) {
        double totalAngle = degreesPerMeter * distance;
        return new AngularMeasurement(totalAngle, DEGREE_SYMBOL);
    }

    // Calculate temperature gradient
    public static AngularMeasurement calculateTemperatureGradient(
            double celsiusPerKm, double altitudeKm) {
        double tempChange = celsiusPerKm * altitudeKm;
        return new AngularMeasurement(tempChange, DEGREE_SYMBOL + "C");
    }

    public static void main(String[] args) {
        // Angular velocity example
        double angularSpeed = 15.0; // degrees per second
        double duration = 5.0;      // seconds

        AngularMeasurement rotation = calculateAngularVelocity(angularSpeed, duration);
        System.out.println("Total rotation: " + rotation + " in " + duration + "s");
        System.out.println("Rate: " + angularSpeed + DEGREE_PER_SECOND);

        // Slope calculation example
        double gradient = 2.5;  // degrees per meter
        double distance = 10.0; // meters

        AngularMeasurement slope = calculateSlope(gradient, distance);
        System.out.println("Slope: " + gradient + DEGREE_PER_METER + " over " +
                          distance + "m = " + slope);
    }
}