Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-opus-4-20250514-thinking-16k· AnthropicHugging Face LMArena Human Preference 140K

как преобразовать концентрацию масс в поле векторов орбитальных скоростей…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Metallama-4-scout-17b-16e-instruct’s answer.
  1. User

    как преобразовать концентрацию масс в поле векторов орбитальных скоростей (приблизительно)? например я имею на входе 10000 случайных частиц, а на выходе 1024*1024 в которой каждый пиксель соответствует орбитальной скорости относительно концентраций масс в этих частицах.

    реализуй html js canvas 2d на выходе я хочу иметь 2 canvas: раскрашенный соответственно направлению векторов орбит раскрашенный соответственно модулю орбитальной скорости

  2. Claude Assistant

    Вот реализация визуализации поля орбитальных скоростей:

    <!DOCTYPE html>
    <html lang="ru">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Поле орбитальных скоростей</title>
        <style>
            body {
                margin: 0;
                padding: 20px;
                background-color: #222;
                color: white;
                font-family: Arial, sans-serif;
            }
            .container {
                display: flex;
                flex-wrap: wrap;
                gap: 20px;
            }
            .canvas-wrapper {
                border: 1px solid #555;
            }
            canvas {
                display: block;
            }
            .controls {
                margin-bottom: 20px;
            }
            button {
                padding: 10px 20px;
                margin-right: 10px;
                cursor: pointer;
            }
        </style>
    </head>
    <body>
        <div class="controls">
            <button onclick="regenerate()">Сгенерировать заново</button>
            <label>
                Количество частиц: 
                <input type="number" id="particleCount" value="1000" min="100" max="10000">
            </label>
        </div>
        
        <div class="container">
            <div class="canvas-wrapper">
                <h3>Направление орбитальных скоростей</h3>
                <canvas id="directionCanvas" width="512" height="512"></canvas>
            </div>
            <div class="canvas-wrapper">
                <h3>Модуль орбитальной скорости</h3>
                <canvas id="magnitudeCanvas" width="512" height="512"></canvas>
            </div>
        </div>
    
        <script>
            const CANVAS_SIZE = 512;
            const FIELD_SIZE = 512; // Уменьшено для производительности
            const G = 1.0; // Условная гравитационная постоянная
            
            let particles = [];
            
            // Генерация случайных частиц
            function generateParticles(count) {
                particles = [];
                for (let i = 0; i < count; i++) {
                    particles.push({
                        x: Math.random() * CANVAS_SIZE,
                        y: Math.random() * CANVAS_SIZE,
                        mass: Math.random() * 10 + 1
                    });
                }
            }
            
            // Вычисление орбитальной скорости в точке
            function calculateOrbitalVelocity(px, py) {
                let totalForceX = 0;
                let totalForceY = 0;
                let dominantMass = 0;
                let dominantDist = Infinity;
                let dominantX = 0;
                let dominantY = 0;
                
                // Находим доминирующую массу и суммарную силу
                for (let particle of particles) {
                    const dx = particle.x - px;
                    const dy = particle.y - py;
                    const distSq = dx * dx + dy * dy;
                    
                    if (distSq < 1) continue; // Избегаем деления на 0
                    
                    const dist = Math.sqrt(distSq);
                    const force = G * particle.mass / distSq;
                    
                    totalForceX += force * dx / dist;
                    totalForceY += force * dy / dist;
                    
                    // Находим ближайшую/доминирующую массу
                    const influence = particle.mass / dist;
                    if (influence > dominantMass / dominantDist) {
                        dominantMass = particle.mass;
                        dominantDist = dist;
                        dominantX = particle.x;
                        dominantY = particle.y;
                    }
                }
                
                // Вектор к доминирующей массе
                const toCenterX = dominantX - px;
                const toCenterY = dominantY - py;
                const distToCenter = Math.sqrt(toCenterX * toCenterX + toCenterY * toCenterY);
                
                if (distToCenter < 1) {
                    return { vx: 0, vy: 0, magnitude: 0 };
                }
                
                // Орбитальная скорость относительно доминирующей массы
                const orbitalSpeed = Math.sqrt(G * dominantMass / distToCenter);
                
                // Направление орбиты - перпендикулярно радиус-вектору
                const normalizedX = toCenterX / distToCenter;
                const normalizedY = toCenterY / distToCenter;
                
                // Поворот на 90 градусов для получения тангенциального направления
                const vx = -normalizedY * orbitalSpeed;
                const vy = normalizedX * orbitalSpeed;
                
                return {
                    vx: vx,
                    vy: vy,
                    magnitude: orbitalSpeed
                };
            }
            
            // Преобразование HSL в RGB
            function hslToRgb(h, s, l) {
                h = h / 360;
                let r, g, b;
                
                if (s === 0) {
                    r = g = b = l;
                } else {
                    const hue2rgb = (p, q, t) => {
                        if (t < 0) t += 1;
                        if (t > 1) t -= 1;
                        if (t < 1/6) return p + (q - p) * 6 * t;
                        if (t < 1/2) return q;
                        if (t < 2/3) return p + (q - p) * (2/3 - t) * 6;
                        return p;
                    };
                    
                    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
                    const p = 2 * l - q;
                    r = hue2rgb(p, q, h + 1/3);
                    g = hue2rgb(p, q, h);
                    b = hue2rgb(p, q, h - 1/3);
                }
                
                return {
                    r: Math.round(r * 255),
                    g: Math.round(g * 255),
                    b: Math.round(b * 255)
                };
            }
            
            // Отрисовка полей
            function renderFields() {
                const dirCanvas = document.getElementById('directionCanvas');
                const magCanvas = document.getElementById('magnitudeCanvas');
                const dirCtx = dirCanvas.getContext('2d');
                const magCtx = magCanvas.getContext('2d');
                
                const dirImageData = dirCtx.createImageData(FIELD_SIZE, FIELD_SIZE);
                const magImageData = magCtx.createImageData(FIELD_SIZE, FIELD_SIZE);
                
                let maxMagnitude = 0;
                const velocityField = [];
                
                // Первый проход - вычисляем поле и находим максимум
                for (let y = 0; y < FIELD_SIZE; y++) {
                    velocityField[y] = [];
                    for (let x = 0; x < FIELD_SIZE; x++) {
                        const velocity = calculateOrbitalVelocity(
                            x * CANVAS_SIZE / FIELD_SIZE,
                            y * CANVAS_SIZE / FIELD_SIZE
                        );
                        velocityField[y][x] = velocity;
                        maxMagnitude = Math.max(maxMagnitude, velocity.magnitude);
                    }
                }
                
                // Второй проход - отрисовка
                for (let y = 0; y < FIELD_SIZE; y++) {
                    for (let x = 0; x < FIELD_SIZE; x++) {
                        const idx = (y * FIELD_SIZE + x) * 4;
                        const velocity = velocityField[y][x];
                        
                        // Направление - цвет по углу
                        const angle = Math.atan2(velocity.vy, velocity.vx);
                        const hue = (angle + Math.PI) * 180 / Math.PI;
                        const dirColor = hslToRgb(hue, 1, 0.5);
                        
                        dirImageData.data[idx] = dirColor.r;
                        dirImageData.data[idx + 1] = dirColor.g;
                        dirImageData.data[idx + 2] = dirColor.b;
                        dirImageData.data[idx + 3] = 255;
                        
                        // Модуль - градиент от синего к красному
                        const normalizedMag = velocity.magnitude / (maxMagnitude + 0.001);
                        const magHue = 240 - normalizedMag * 240; // От синего (240) к красному (0)
                        const magColor = hslToRgb(magHue, 1, 0.5);
                        
                        magImageData.data[idx] = magColor.r;
                        magImageData.data[idx + 1] = magColor.g;
                        magImageData.data[idx + 2] = magColor.b;
                        magImageData.data[idx + 3] = 255;
                    }
                }
                
                dirCtx.putImageData(dirImageData, 0, 0);
                magCtx.putImageData(magImageData, 0, 0);
                
                // Отрисовка частиц
                dirCtx.fillStyle = 'white';
                magCtx.fillStyle = 'white';
                
                for (let particle of particles) {
                    const x = particle.x * FIELD_SIZE / CANVAS_SIZE;
                    const y = particle.y * FIELD_SIZE / CANVAS_SIZE;
                    const radius = Math.sqrt(particle.mass) * 2;
                    
                    dirCtx.beginPath();
                    dirCtx.arc(x, y, radius, 0, Math.PI * 2);
                    dirCtx.fill();
                    
                    magCtx.beginPath();
                    magCtx.arc(x, y, radius, 0, Math.PI * 2);
                    magCtx.fill();
                }
            }
            
            function regenerate() {
                const count = parseInt(document.getElementById('particleCount').value);
                generateParticles(count);
                renderFields();
            }
            
            // Инициализация
            regenerate();
        </script>
    </body>
    </html>
    

    Эта реализация:

    1. Генерирует случайные частицы с позициями и массами

    2. Вычисляет поле орбитальных скоростей:

      • Для каждой точки поля находит доминирующую массу
      • Вычисляет орбитальную скорость по формуле v = √(GM/r)
      • Направление орбиты перпендикулярно радиус-вектору
    3. Визуализирует два поля:

      • Направление: цвет определяется углом вектора скорости (полный спектр HSL)
      • Модуль: градиент от синего (низкая скорость) к красному (высокая скорость)
    4. Отображает сами частицы белыми кругами, размер которых пропорционален массе

    Вы можете изменить количество частиц и регенерировать поле. Код оптимизирован для работы в реальном времени, используя поле 512×512 вместо 1024×1024 для лучшей производительности.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.