From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- .../star/comp/Calc/NLPSolver/DEPSSolverImpl.java | 212 +++++++++++++++++++++ 1 file changed, 212 insertions(+) create mode 100644 nlpsolver/src/com/sun/star/comp/Calc/NLPSolver/DEPSSolverImpl.java (limited to 'nlpsolver/src/com/sun/star/comp/Calc/NLPSolver/DEPSSolverImpl.java') diff --git a/nlpsolver/src/com/sun/star/comp/Calc/NLPSolver/DEPSSolverImpl.java b/nlpsolver/src/com/sun/star/comp/Calc/NLPSolver/DEPSSolverImpl.java new file mode 100644 index 000000000..2b6c1ce36 --- /dev/null +++ b/nlpsolver/src/com/sun/star/comp/Calc/NLPSolver/DEPSSolverImpl.java @@ -0,0 +1,212 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2009 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +package com.sun.star.comp.Calc.NLPSolver; + +import java.util.logging.Level; +import java.util.logging.Logger; + +import net.adaptivebox.deps.DEPSAgent; +import net.adaptivebox.deps.behavior.DEGTBehavior; +import net.adaptivebox.deps.behavior.PSGTBehavior; +import net.adaptivebox.global.IUpdateCycleEngine; +import net.adaptivebox.knowledge.Library; +import net.adaptivebox.knowledge.SearchPoint; +import net.adaptivebox.space.BasicPoint; + +import com.sun.star.comp.Calc.NLPSolver.dialogs.IEvolutionarySolverStatusDialog; +import com.sun.star.lang.IllegalArgumentException; +import com.sun.star.lang.XSingleComponentFactory; +import com.sun.star.lib.uno.helper.Factory; +import com.sun.star.registry.XRegistryKey; +import com.sun.star.uno.XComponentContext; + + +public final class DEPSSolverImpl extends BaseEvolutionarySolver + implements com.sun.star.lang.XServiceInfo +{ + private static final String m_implementationName = DEPSSolverImpl.class.getName(); + private static final String[] m_serviceNames = { + "com.sun.star.sheet.Solver", + "com.sun.star.beans.PropertySet" + }; + + public DEPSSolverImpl( XComponentContext context ) + { + super(context, "DEPS Evolutionary Algorithm"); + + registerProperty(m_agentSwitchRate); + registerProperty(m_minFactor); + registerProperty(m_maxFactor); + registerProperty(m_CR); + registerProperty(m_c1); + registerProperty(m_c2); + registerProperty(m_weight); + registerProperty(m_CL); + } + + public static XSingleComponentFactory __getComponentFactory( String sImplementationName ) { + XSingleComponentFactory xFactory = null; + + if ( sImplementationName.equals( m_implementationName ) ) + xFactory = Factory.createComponentFactory(DEPSSolverImpl.class, m_serviceNames); + return xFactory; + } + + public static boolean __writeRegistryServiceInfo( XRegistryKey xRegistryKey ) { + return Factory.writeRegistryServiceInfo(m_implementationName, + m_serviceNames, + xRegistryKey); + } + + // com.sun.star.lang.XServiceInfo: + public String getImplementationName() { + return m_implementationName; + } + + public boolean supportsService( String sService ) { + int len = m_serviceNames.length; + + for( int i=0; i < len; i++) { + if (sService.equals(m_serviceNames[i])) + return true; + } + return false; + } + + public String[] getSupportedServiceNames() { + return m_serviceNames; + } + + private final PropertyInfo m_agentSwitchRate = new PropertyInfo("AgentSwitchRate", 0.5, "Agent Switch Rate (DE Probability)"); + // --DE + private final PropertyInfo m_minFactor = new PropertyInfo("DEFactorMin", 0.5, "DE: Min Scaling Factor (0-1.2)"); + private final PropertyInfo m_maxFactor = new PropertyInfo("DEFactorMax", 0.5, "DE: Max Scaling Factor (0-1.2)"); + private final PropertyInfo m_CR = new PropertyInfo("DECR", 0.9, "DE: Crossover Probability (0-1)"); + // --PS + private final PropertyInfo m_c1 = new PropertyInfo("PSC1", 1.494, "PS: Cognitive Constant"); + private final PropertyInfo m_c2 = new PropertyInfo("PSC2", 1.494, "PS: Social Constant"); + private final PropertyInfo m_weight = new PropertyInfo("PSWeight", 0.729, "PS: Constriction Coefficient"); + private final PropertyInfo m_CL = new PropertyInfo("PSCL", 0.0, "PS: Mutation Probability (0-0.005)"); + + public void solve() { + try { + m_librarySize.setValue(m_swarmSize.getValue()); //DEPS' library is as large as the swarm + } catch (IllegalArgumentException ex) { + Logger.getLogger(DEPSSolverImpl.class.getName()).log(Level.SEVERE, null, ex); + } + initializeSolve(); + if (m_problemEncoder == null) + { + return; + } + + //Init: + DEPSAgent[] agents = new DEPSAgent[m_swarmSize.getValue()]; + for (int i = 0; i < m_swarmSize.getValue(); i++) { + DEGTBehavior deGTBehavior = new DEGTBehavior(); + deGTBehavior.MIN_FACTOR = Math.min(m_minFactor.getValue(), m_maxFactor.getValue()); + deGTBehavior.MAX_FACTOR = Math.max(m_minFactor.getValue(), m_maxFactor.getValue()); + deGTBehavior.CR = m_CR.getValue(); + deGTBehavior.setLibrary(m_library); + + PSGTBehavior psGTBehavior = new PSGTBehavior(); + psGTBehavior.c1 = m_c1.getValue(); + psGTBehavior.c2 = m_c2.getValue(); + psGTBehavior.CL = m_CL.getValue(); + psGTBehavior.weight = m_weight.getValue(); + psGTBehavior.setLibrary(m_library); + + agents[i] = new DEPSAgent(m_problemEncoder, deGTBehavior, psGTBehavior, + m_agentSwitchRate.getValue(), m_specCompareEngine, + m_library.getSelectedPoint(i)); + } + + //Learn: + m_solverStatusDialog.setVisible(true); + m_solverStatusDialog.setMaxIterations(m_learningCycles.getValue()); + m_solverStatusDialog.setMaxStagnation(m_required.getValue()); + int learningCycle = 1; + long runtime = 0; + do { + long startTime = System.nanoTime(); + + if (learningCycle >= m_learningCycles.getValue()) + learningCycle = 1; + + if (m_solverStatusDialog.getUserState() == IEvolutionarySolverStatusDialog.CONTINUE) + lockDocument(); + + m_toleratedCount = 0; + m_toleratedMin = -1.0 * m_tolerance.getValue(); + m_toleratedMax = m_tolerance.getValue(); + for (; learningCycle <= m_learningCycles.getValue() && + m_toleratedCount < m_required.getValue() && + m_solverStatusDialog.getUserState() != IEvolutionarySolverStatusDialog.CANCEL; learningCycle++) { + m_library.refreshGbest(m_specCompareEngine); + + for (int i = 0; i < m_swarmSize.getValue(); i++) + agents[i].generatePoint(); + + for (int i = 0; i < m_swarmSize.getValue(); i++) + agents[i].learn(); + + for (int i = 0; i < m_swarmSize.getValue(); i++) { + SearchPoint agentPoint = agents[i].getMGState(); + boolean inRange = (agentPoint.getObjectiveValue() >= m_toleratedMin && agentPoint.getObjectiveValue() <= m_toleratedMax); + if (Library.replace(m_envCompareEngine, agentPoint, m_totalBestPoint)) { + m_solverStatusDialog.setBestSolution(m_totalBestPoint.getObjectiveValue(), m_totalBestPoint.isFeasible()); + if (!inRange) { + m_toleratedMin = agentPoint.getObjectiveValue() - m_tolerance.getValue(); + m_toleratedMax = agentPoint.getObjectiveValue() + m_tolerance.getValue(); + m_toleratedCount = 0; + } + } + } + + if (m_specCompareEngine instanceof IUpdateCycleEngine) + ((IUpdateCycleEngine)m_specCompareEngine).updateCycle(learningCycle); + + m_solverStatusDialog.setIteration(learningCycle); + m_solverStatusDialog.setStagnation(m_toleratedCount); + m_solverStatusDialog.setRuntime(runtime + (System.nanoTime() - startTime)); + m_xReschedule.reschedule(); + } + + applySolution(); //show the current solution + unlockDocument(); //allow the solution to be displayed + + runtime += (System.nanoTime() - startTime); + m_solverStatusDialog.setRuntime(runtime); + } while (m_solverStatusDialog.waitForUser() == IEvolutionarySolverStatusDialog.CONTINUE); + + lockDocument(); + + finalizeSolve(); + } + +} -- cgit v1.2.3