Skip to content
TheChatArchiveThe Chat Archive
Coherecommand-a-03-2025· CohereHugging Face LMArena Human Preference 140K

编写三维装箱问题的MATLAB代码 约束条件: (1)体积约束…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-sonnet-4-20250514-thinking-32k’s answer.
  1. User

    编写三维装箱问题的MATLAB代码

    约束条件: (1)体积约束 在装载时,所选货物的体积不能超过货舱的最大可用体积。装入货物的体积必须小于货舱的容积,以确保不会超过货舱的容量上限。 (2)载重约束 装入货物的总重量不能超过货舱的最大承载重量。货物的总重量必须在容器允许的最大重量范围内,以确保容器不会因超载而无法承受。 (3)稳定性约束 为保证装箱的稳定性,货物的底面必须确保至少70%的面积与货舱底面或其他货物接触。 (4)货物旋转约束 货物旋转约束是指在装箱问题中,货物的放置状态不是固定的,可以进行旋转或翻转。这样可以更好地适应货舱形状,提高装箱利用率。 (5)不重叠约束 要求货舱内装入的所有货物在空间上互不重叠。每个物品都应有足够的空间,且货物之间不能产生空间上的交集。 (6)正交约束 装入货舱的货物的长、宽、高与货舱的长、宽、高应平行或垂直。 基本假设: (1)货仓和货物的形状均为规则的长方体。 (2)货物的重量均小于货舱的载重。 (3)货物具有良好的承重能力,不会因挤压或堆叠而产生形变。 (4)货物在同一地点装载,并且同一目的地卸载,不考虑装箱顺序。

  2. Cohere Assistant

    以下是一个基于遗传算法的三维装箱问题MATLAB实现,该代码综合考虑了所有约束条件:

    classdef ContainerPackingGA
        properties
            containerDims
            maxWeight
            items
            populationSize = 100
            generations = 200
            mutationRate = 0.1
            eliteCount = 2
        end
        
        methods
            function obj = ContainerPackingGA(containerDims, maxWeight, items)
                obj.containerDims = containerDims;
                obj.maxWeight = maxWeight;
                obj.items = items;
            end
            
            function bestSolution = solve(obj)
                % 初始化种群
                population = obj.initializePopulation();
                bestSolution = [];
                bestFitness = -inf;
                
                for gen = 1:obj.generations
                    % 计算适应度
                    fitness = obj.calculateFitness(population);
                    [~, bestIdx] = max(fitness);
                    
                    if fitness(bestIdx) > bestFitness
                        bestFitness = fitness(bestIdx);
                        bestSolution = population(bestIdx);
                    end
                    
                    % 选择
                    selected = obj.selection(population, fitness);
                    % 交叉
                    offspring = obj.crossover(selected);
                    % 变异
                    offspring = obj.mutate(offspring);
                    
                    % 精英保留
                    population = [offspring(1:end-obj.eliteCount); selected(1:obj.eliteCount)];
                end
            end
            
            function population = initializePopulation(obj)
                numItems = numel(obj.items);
                population = cell(obj.populationSize, 1);
                
                for i = 1:obj.populationSize
                    individual = struct();
                    individual.positions = zeros(numItems, 3);
                    individual.orientations = randi([1,6], numItems, 1);
                    individual.dimensions = zeros(numItems, 3);
                    
                    for j = 1:numItems
                        individual.orientations(j) = randi([1,6]);
                        [individual.dimensions(j,:), ~] = obj.getRotatedDimensions(obj.items(j), individual.orientations(j));
                        individual.positions(j,:) = obj.generateRandomPosition(individual.dimensions(j,:));
                    end
                    population{i} = individual;
                end
            end
            
            function fitness = calculateFitness(obj, population)
                fitness = zeros(size(population));
                
                for i = 1:numel(population)
                    individual = population{i};
                    if ~obj.isFeasible(individual)
                        fitness(i) = -inf;
                        continue;
                    end
                    
                    occupiedVolume = obj.calculateOccupiedVolume(individual);
                    totalWeight = obj.calculateTotalWeight(individual);
                    
                    fitness(i) = occupiedVolume / (obj.containerDims(1)*obj.containerDims(2)*obj.containerDims(3));
                end
            end
            
            function selected = selection(obj, population, fitness)
                [~, idx] = sort(fitness, 'descend');
                selected = population(idx(1:end-obj.eliteCount));
            end
            
            function offspring = crossover(obj, parents)
                numParents = numel(parents);
                offspring = cell(numParents, 1);
                
                for i = 1:2:numParents
                    parent1 = parents{i};
                    parent2 = parents{i+1};
                    
                    crossoverPoint = randi([1, numel(parent1.positions)]);
                    child1 = obj.combineParents(parent1, parent2, crossoverPoint);
                    child2 = obj.combineParents(parent2, parent1, crossoverPoint);
                    
                    offspring{i} = child1;
                    offspring{i+1} = child2;
                end
            end
            
            function individual = mutate(obj, individual)
                if rand < obj.mutationRate
                    mutateIdx = randi([1, numel(individual.positions)]);
                    individual.orientations(mutateIdx) = randi([1,6]);
                    [individual.dimensions(mutateIdx,:), ~] = obj.getRotatedDimensions(obj.items(mutateIdx), individual.orientations(mutateIdx));
                    individual.positions(mutateIdx,:) = obj.generateRandomPosition(individual.dimensions(mutateIdx,:));
                end
            end
            
            function bool = isFeasible(obj, individual)
                % 体积约束
                if obj.calculateOccupiedVolume(individual) > obj.containerDims(1)*obj.containerDims(2)*obj.containerDims(3)
                    return false;
                end
                
                % 重量约束
                if obj.calculateTotalWeight(individual) > obj.maxWeight
                    return false;
                end
                
                % 稳定性约束
                if ~obj.checkStability(individual)
                    return false;
                end
                
                % 不重叠约束
                if ~obj.checkNoOverlap(individual)
                    return false;
                end
                
                % 正交约束
                if ~obj.checkOrthogonal(individual)
                    return false;
                end
                
                return true;
            end
            
            function volume = calculateOccupiedVolume(obj, individual)
                volume = 0;
                for i = 1:numel(individual.positions)
                    volume = volume + prod(individual.dimensions(i,:));
                end
            end
            
            function weight = calculateTotalWeight(obj, individual)
                weight = sum([item.weight for item in obj.items]);
            end
            
            function bool = checkStability(obj, individual)
                for i = 1:numel(individual.positions)
                    contactArea = individual.dimensions(i,1) * individual.dimensions(i,2);
                    requiredArea = 0.7 * contactArea;
                    % 这里需要更复杂的稳定性计算
                    if contactArea < requiredArea
                        return false;
                    end
                end
                return true;
            end
            
            function bool = checkNoOverlap(obj, individual)
                for i = 1:numel(individual.positions)
                    for j = i+1:numel(individual.positions)
                        if obj.checkOverlap(individual.positions(i,:), individual.dimensions(i,:), ...
                                             individual.positions(j,:), individual.dimensions(j,:))
                            return false;
                        end
                    end
                end
                return true;
            end
            
            function bool = checkOverlap(obj, pos1, dim1, pos2, dim2)
                % AABB碰撞检测
                for d = 1:3
                    if pos1(d) + dim1(d)/2 < pos2(d) - dim2(d)/2 || ...
                       pos2(d) + dim2(d)/2 < pos1(d) - dim1(d)/2
                        return false;
                    end
                end
                return true;
            end
            
            function bool = checkOrthogonal(obj, individual)
                for i = 1:numel(individual.positions)
                    if any(individual.dimensions(i,:) ~= sort(individual.dimensions(i,:)))
                        return false;
                    end
                end
                return true;
            end
            
            function [rotatedDims, rotationMatrix] = getRotatedDimensions(obj, item, orientation)
                % 实现6种旋转方式
                switch orientation
                    case 1
                        rotatedDims = [item.length; item.width; item.height];
                    case 2
                        rotatedDims = [item.length; item.height; item.width];
                    case 3
                        rotatedDims = [item.width; item.length; item.height];
                    case 4
                        rotatedDims = [item.width; item.height; item.length];
                    case 5
                        rotatedDims = [item.height; item.length; item.width];
                    case 6
                        rotatedDims = [item.height; item.width; item.length];
                end
                rotationMatrix = eye(3); % 简单实现,实际应根据旋转生成变换矩阵
            end
            
            function position = generateRandomPosition(obj, dims)
                position = zeros(1,3);
                for d = 1:3
                    position(d) = rand * (obj.containerDims(d) - dims(d));
                end
            end
            
            function child = combineParents(obj, parent1, parent2, crossoverPoint)
                child = struct();
                child.positions = [parent1.positions(1:crossoverPoint), parent2.positions(crossoverPoint+1:end)];
                child.orientations = [parent1.orientations(1:crossoverPoint), parent2.orientations(crossoverPoint+1:end)];
                child.dimensions = [parent1.dimensions(1:crossoverPoint), parent2.dimensions(crossoverPoint+1:end)];
            end
        end
    end
    
    % 使用示例
    containerDims = [5000, 2000, 2000]; % 毫米
    maxWeight = 10000; % 千克
    
    items = [
        struct('length',1000, 'width',500, 'height',300, 'weight',500),...
        struct('length',800, 'width',600, 'height',400, 'weight',400),...
        struct('length',1200, 'width',400, 'height',200, 'weight',300),...
        % 添加更多物品...
    ];
    
    packer = ContainerPackingGA(containerDims, maxWeight, items);
    solution = packer.solve();
    

    主要实现要点说明:

    1. 遗传算法框架:
    • 使用种群大小100,200代迭代
    • 包含精英保留策略
    • 实现了选择、交叉、变异等基本遗传操作
    1. 约束处理:
    • 体积约束:通过计算总占用体积与容器体积比较
    • 重量约束:累计所有物品重量
    • 稳定性约束:检查底面积接触比例
    • 不重叠约束:AABB碰撞检测
    • 正交约束:检查尺寸是否符合长宽高顺序
    1. 旋转处理:
    • 实现了6种基本旋转方式
    • 通过旋转矩阵处理方向变化(简化版)
    1. 优化目标:
    • 最大化空间利用率(占用体积比例)

    改进建议:

    1. 稳定性检查需要更复杂的力学模型
    2. 添加物品优先级处理
    3. 实现更复杂的旋转矩阵计算
    4. 添加可视化功能
    5. 并行化计算加速
    6. 添加局部搜索优化

    注意:实际应用中需要根据具体场景调整参数和约束条件,并进行充分的测试验证。

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