apis/examples_java/TransportEngine_8java_source.html

패키지com.메가 슬롯examples.transport;


가져오기java.io.*;

가져오기java.nio.file.*;

가져오기java.util.*;

가져오기java.nio.charset.*;


가져오기 com.게임.API.*;


공개 클래스운송엔진{


   공개 정적 무효main(String[] args)

        GAMSWorkspaceInfowsInfo =신규 GAMSWorkspaceInfo();

        // 명령줄 인수에서 작업공간 정보 확인

        if(args.length > 0)

wsInfo.setSystemDirectory( 인수[0] );

        // 현재 작업 디렉토리 아래에 "TransportEngine"이라는 이름의 작업 디렉토리를 생성

파일 WorkingDirectory =신규파일(System.getProperty("user.dir"), "운송엔진");

workingDirectory.mkdir();

wsInfo.setWorkingDirectory(workingDirectory.getAbsolutePath());

        // 사용자가 지정한 시스템 디렉터리로 GAMSWorkspace "ws"를 생성

        메가 슬롯작업공간ws =신규 메가 슬롯작업공간(wsInfo);


문자열 엔진_url = System.getenv("엔진_URL");

        if(engine_url ==널) {

System.out.println("오류: 환경 변수 ENGINE_URL이 설정되지 않았습니다");

System.exit(-1);

}

문자열 엔진_user = System.getenv("엔진_사용자");

        if(engine_user ==널) {

System.out.println("오류: 환경 변수 ENGINE_USER가 설정되지 않았습니다");

System.exit(-1);

}

문자열 엔진_비밀번호 = System.getenv("엔진_비밀번호");

        if(engine_password ==널) {

System.out.println("오류: 환경 변수 ENGINE_PASSWORD가 설정되지 않았습니다");

System.exit(-1);

}

문자열 Engine_namespace = System.getenv("ENGINE_NAMESPACE");

        if(engine_namespace ==널) {

System.out.println("오류: 환경 변수 ENGINE_NAMESPACE가 설정되지 않았습니다");

System.exit(-1);

}


        // 메가 슬롯 엔진의 모든 작업에 필요한 구성 설정

        GAMSEngineConfiguration엔진_구성 =신규 GAMSEngineConfiguration(

엔진_URL,

엔진_사용자,

엔진_비밀번호,

                                                            "",

engine_namespace

);

        // 엔진 작업 실행

runEngineJob(ws, 엔진_configuration);


        // 엔진 작업 실행 및 중단

runAndInterruptEngineJob(ws, 엔진_configuration);


        // 종료

System.exit(0);

}


    /* 엔진 작업 실행 방법 예시 */

    정적 공허runEngineJob(메가 슬롯작업공간ws,GAMSEngineConfiguration엔진_구성)

        /* GDX 파일로 명시적으로 내보내기와 함께 메가 슬롯 구문을 사용하여 문자열의 데이터로 실행 */

        GAMSJobtEdata = ws.addJobFromString(데이터);

        시도해 보세요{

System.out.println("문자열에서 데이터 실행 중");

tEdata.runEngine( 신규 GAMSEngineRunParameters.newBuilder()

.setRunEngineConfiguration(engine_configuration)

.setOutput( System.out )

.build()

);

}잡기 (메가 슬롯예외e)

System.out.println("오류: "+ 전자.getMessage());

System.exit(-1);

}

        메가 슬롯데이터베이스tEDataDB = tEdata.아웃DB();

tEDataDB.내보내기("tdata.gdx");


Map<String, Double> ExpectLevels =신규HashMap<String, Double>();

{

expectedLevels.put("seattle.new-york", Double.valueOf(0.0));

예상레벨.put("seattle.chicago", Double.valueOf(300.0));

예상레벨.put("seattle.topeka", Double.valueOf(0.0));

예상레벨.put("san-diego.new-york", Double.valueOf(325.0));

expectedLevels.put("san-diego.chicago", Double.valueOf(0.0));

expectedLevels.put("san-diego.topeka", Double.valueOf(275.0));

}


        /* 데이터 포함 파일을 정의하는 GAMSOptions 인스턴스를 사용하여 작업 실행 */

        GAMSJobtEmodel = ws.addJobFromString(모델);

        메가 슬롯옵션opt = ws.추가옵션();

선택.정의("gdxincname", "tdata");

선택.setAllModelTypes("익스프레스");

        시도해 보세요{

System.out.println("데이터 포함 파일을 정의하는 GAMSOptions 인스턴스를 사용하여 실행 중입니다.");

tEmodel.runEngine( 신규 GAMSEngineRunParameters.newBuilder()

.setRunEngineConfiguration(engine_configuration)

.setGAMSOptions( 선택 )

                                                    .setExtraModelFiles( 신규HashSet<String>(Arrays.asList("tdata.gdx")) )

                                                    .setEngineOptions( 신규HashMap<문자열, 문자열>()

넣어("inex_string", "\"유형\": \"포함\", \"파일\": [\"*.gdx\"]"); }

})

.build()

);


System.out.println("데이터 포함 파일을 정의하는 GAMSOptions 인스턴스를 사용하여 모델을 실행했습니다:");

            for (GAMSVariableRecordrec : tEmodel.아웃DB().get변수("x")) {

System.out.print("x("+ rec.getKey(0) +", "+ rec.getKey(1) +"):");

System.out.print(", 레벨 = "+ rec.getLevel());

System.out.println(", 한계 = "+ rec.getMarginal());

                더블diff = 예상레벨.get(rec.getKey(0)+"."+rec.getKey(1)).doubleValue() - rec.getLevel();

                if(Math.abs(diff) > 0.01)

System.out.println("예상치 못한 결과, 예상 수준: "+expectedLevels.get(rec.getKey(0)+"."+rec.getKey(1)));

System.exit(-1);

}

}

}잡기 (메가 슬롯예외e)

System.out.println("오류: "+ 전자.getMessage());

System.exit(-1);

}


        /* 동일하지만 암시적 데이터베이스 통신이 있음 */

        GAMSJobtEa = ws.addJobFromString(데이터);

        시도{

System.out.println("문자열에서 데이터를 실행 중입니다.");

tEa.runEngine( 신규 GAMSEngineRunParameters.newBuilder()

.setRunEngineConfiguration(engine_configuration)

.setOutput( System.out )

.build()

);

}잡기 (메가 슬롯예외e)

System.out.println("오류: "+ 전자.getMessage());

System.exit(-1);

}


        GAMSJobtEb = ws.addJobFromString(모델);


        메가 슬롯체크포인트cp = ws.addCheckpoint();

        메가 슬롯옵션옵션 = ws.추가옵션();

옵션.정의("gdxincname", tEa.아웃DB().getName());

옵션.setAllModelTypes("익스프레스");


        시도해 보세요{

System.out.println("체크포인트 암시적 데이터베이스 통신을 사용하여 문자열에서 모델을 실행 중입니다.");

tEb.runEngine( 신규 GAMSEngineRunParameters.newBuilder()

.setRunEngineConfiguration(engine_configuration)

.setGAMSOptions( 옵션 )

.setGAMSCheckpoint(cp )

.setDatabases(신규ArrayList<GAMSDatabase>(Arrays.asList(tEa.아웃DB())) )

.setOutput( System.out )

.build()

);

System.out.println("체크포인트 암시적 데이터베이스 통신을 사용하여 문자열에서 모델을 실행했습니다:");

            for (GAMSVariableRecordrec : tEb.아웃DB().get변수("x")) {

System.out.print("x("+ rec.getKey(0) +", "+ rec.getKey(1) +"):");

System.out.print(", 레벨 = "+ rec.getLevel());

System.out.println(", 한계 = "+ rec.getMarginal());

                더블diff = 예상레벨.get(rec.getKey(0)+"."+rec.getKey(1)).doubleValue() - rec.getLevel();

                if(Math.abs(diff) > 0.01)

System.out.println("예상치 못한 결과, 예상 수준: "+expectedLevels.get(rec.getKey(0)+"."+rec.getKey(1)));

System.exit(-1);

}

}

}잡기 (메가 슬롯예외e)

System.out.println("오류: "+ 전자.getMessage());

System.exit(-1);

}


목록<HashMap<String, Double>> bmultExpected =신규ArrayList<HashMap<String, Double>>();

bmultExpected.add(신규HashMap<String, Double>()

넣어("bmult", Double.valueOf(0.9) );

put("ms", Double.valueOf(1) );

put("ss", Double.valueOf(1) );

put("obj", Double.valueOf(138.31) );

}

} );

bmultExpected.add(신규HashMap<String, Double>()

넣어("bmult", Double.valueOf(1.2) );

put("ms", Double.valueOf(4) );

put("ss", Double.valueOf(1) );

put("obj", Double.valueOf(184.41) );

}

} );


        for(HashMap<String, Double> m : bmultExpected)

문자열 bmultmodel ="bmult="+m.get("bmult")+"; lp를 사용하여 전송 최소 z 해결; ms=transport.modelstat; ss=transport.solvestat;";

            GAMSJobtEbmult = ws.addJobFromString( bmultmodel, cp );

            시도해 보세요{

System.out.println("bmult를 사용하여 문자열에서 모델 실행="+m.get("bmult"));

tEbmult.runEngine( 신규 GAMSEngineRunParameters.newBuilder()

.setRunEngineConfiguration(engine_configuration)

.setOutput( System.out )

.build()

);


System.out.println("bumult를 사용하여 문자열에서 모델을 실행했습니다="+ m.get("bmult").doubleValue() +":");

System.out.println(" 모델 상태: "+ tEbmult.아웃DB().getParameter("ms").getFirstRecord().getValue());

System.out.println(" 해결 상태: "+ tEbmult.아웃DB().getParameter("ss").getFirstRecord().getValue());

System.out.println(" 개체: "+ tEbmult.아웃DB().get변수("z").getFirstRecord().getLevel());

                더블diff = tEbmult.아웃DB().getParameter("bmult").getFirstRecord().getValue() - m.get("bmult").doubleValue();

                if(Math.abs(diff) > 0.01)

System.out.println("예상치 못한 결과, 예상되는 bmult: "+m.get("bmult").doubleValue());

System.exit(-1);

}

diff = tEbmult.아웃DB().getParameter("ms").getFirstRecord().getValue() - m.get("ms").doubleValue();

                if(Math.abs(diff) > 0.01)

System.out.println("예상치 못한 결과, 예상 ms: "+m.get("ms").doubleValue());

System.exit(-1);

}

diff = tEbmult.아웃DB().getParameter("ss").getFirstRecord().getValue() - m.get("ss").doubleValue();

                if(Math.abs(diff) > 0.01)

System.out.println("예상치 못한 결과, 예상된 ss: "+m.get("ss").doubleValue());

System.exit(-1);

}

diff = tEbmult.아웃DB().get변수("z").getFirstRecord().getLevel() - m.get("obj").doubleValue();

                if(Math.abs(diff) > 0.01)

System.out.println("예상치 못한 결과, 예상된 객체: "+m.get("obj").doubleValue());

System.exit(-1);

}


}잡기 (메가 슬롯예외e)

System.out.println("오류: "+ 전자.getMessage());

System.exit(-1);

}


}


        // 옵션 및 데이터베이스 삭제

opt.dispose();

옵션.처분();


tEDataDB.dispose();

}


    정적 무효runAndInterruptEngineJob(메가 슬롯작업공간ws,GAMSEngineConfiguration엔진_구성)

        최종 GAMSJob직업 = ws.addJobFromGamsLib("입은");

        최종 메가 슬롯옵션opt = ws.추가옵션();

선택.setMIP("복합체");

선택.setOptFile(1);

선택.setSolveLink(메가 슬롯옵션.ESolveLink.LoadLibrary);


        시도해 보세요{

파일 로그파일 = Paths.get(ws.workingDirectory(), "jclad.log").toFile();

            부울fileCreated = logFile.createNewFile();


파일 옵션File_1 = Paths.get(ws.workingDirectory(), "cplex.opt").toFile();

FileWriter fw =신규파일 작성기(optionFile_1);

fw.write("epgap 0\n");// 처음에는 상대 중지 허용 오차를 0으로 설정

fw.write("대화형 1\n");// 인터럽트 시 대화형 옵션 설정 활성화

fw.write("iafile cplex.op2\n");// 인터럽트 시 읽을 새 옵션 파일 정의

fw.close();


파일 옵션File_2 = Paths.get(ws.workingDirectory(), "cplex.op2").toFile();

fw =신규파일 작성기(optionFile_2);

fw.write("epgap 0.1\n");// 상대 중지 허용 오차를 0.1로 설정

fw.close();


HashSet<String> extraModelFiles =신규HashSet<문자열>(

Arrays.asList(optionFile_1.getAbsolutePath(), optionFile_2.getAbsolutePath(),"claddat.gdx")

);

            최종근로자 w =신규작업자(작업, 엔진_구성, opt, extraModelFiles,신규PrintStream(로그파일));

w.start();


            그동안 (참)  {

                if(logFile.exists() && logFile.length()==0)

                    시도해 보세요{

Thread.currentThread();

Thread.sleep(500);

}잡기( 예외 e )

e.printStackTrace();

}

                    계속;

}


                // 작업이 아직 종료되지 않은 경우에만 실행 중인 GAMSJob에 인터럽트 신호를 보냅니다.

                부울중단됨 =거짓;

                부울종료됨 = (w.getState()==Thread.State.TERMINATED);

                if(!종료됨)

System.out.println("인터럽트 메가 슬롯 작업을 보내는 중...");

중단됨 = 작업.인터럽트();

}

System.out.println("새 옵션을 계속하기 위해 Cplex가 중단되었습니다.");

                휴식;

}


            if(w.isAlive())

                시도해 보세요{

w.join();

}잡기(InterruptedException e)  e.printStackTrace();

}


            부울중단됨 =거짓;


스캐너 스캔 =신규스캐너(로그파일);

문자열 검색str ="중단되었습니다...";

            그동안(scan.hasNext())

문자열 라인 = scan.nextLine().toLowerCase().toString();

                if(line.contains(searchstr))

System.out.println(line);

중단됨 =참;

                    휴식;

}

}


            if(!중단됨)

System.out.println("솔버가 적어도 한 번은 중단될 것으로 예상됩니다.");

System.exit(-1);

}

System.out.println("성공적으로 중단되었습니다");


}잡기(FileNotFoundException e)

e.printStackTrace();

}잡기(IOException e)

e.printStackTrace();

}

선택.처분();

}


    정적 클래스노동자확장스레드

        GAMSEngineConfiguration구성;

        GAMSJob직업;

        메가 슬롯옵션옵션;

PrintStream 출력;

HashSet<String> extraModelFiles;


        공개노동자(GAMSJobjb,GAMSEngineConfigurationcfg,메가 슬롯옵션opt, HashSet<String> modelFiles, PrintStream 출력)

구성 = cfg;

직업 = jb;

옵션 = 선택;

출력 = 출력;

extraModelFiles = modelFiles;

}


@재정의

        공개 공허실행()

            시도{

System.out.println("메가 슬롯 엔진 작업 실행 중...");

직업.runEngine( 신규 GAMSEngineRunParameters.newBuilder()

.setRunEngineConfiguration(구성)

.setGAMSOptions(옵션)

.setOutput(출력)

                                                        .setExtraModelFiles( extraModelFiles )

.build()

);

}잡기(예외 e)

e.printStackTrace();

System.exit(-1);

}

}

}


    // 데이터

    정적문자열 데이터 =

                   "세트 \n" +

                   " 나는 식물 통조림 / 시애틀, 샌디에고 / \n" +

                   " j 마켓 / 뉴욕, 시카고, 토피카 / ; \n" +

                   "매개변수 \n" +

                   " \n" +

                   " a(i) 경우에 따라 공장 i의 용량 \n" +

                   " / 시애틀 350 \n" +

                   " 샌디에고 600 / \n" +

                   " \n" +

                   " b(j) 경우의 시장 j 수요 \n" +

                   " / 뉴욕 325 \n" +

                   " 시카고 300 \n" +

                   " 토피카 275 / ; \n" +

                   " \n" +

                   "테이블 d(i,j) 거리(천 마일 단위) \n" +

                   " 뉴욕 시카고 토피카 \n" +

                   " 시애틀 2.5 1.7 1.8 \n" +

                   " 샌디에고 2.5 1.8 1.4 ; \n" +

                   " \n" +

                   "스칼라 f '1,000마일당 케이스당 달러 단위의 화물' / 90 / \n" +

                   " bmult '수요 승수' / 1 /;\n" +

                   " \n";


    // 모델

    정적문자열 모델 =

          " 세트 \n"+

          " 나는 '통조림 식물' \n"+

          " j '시장'; \n"+

          " \n"+

          "매개변수 \n"+

          " a(i) '경우에 따라 식물 i의 용량' \n"+

          " b(j) '경우에 따라 시장 j의 수요' \n"+

          " d(i,j) '거리(천 마일)'; \n"+

          " \n"+

          "스칼라 f '1,000마일당 케이스당 달러 단위의 화물'; \n"+

          "스칼라 bmult '수요 승수'; \n"+

          " \n"+

          "$if gdxincname $abort '제공된 데이터 파일에 대한 포함 파일 이름이 설정되지 않았습니다'\n"+

          "$gdxin %gdxincname% \n"+

          "$load i j a b d f bmult \n"+

          "$gdxin \n"+

          " \n"+

          "$echo 테스트 > test.txt \n"+

          " \n"+

          "매개변수 c(i,j) '케이스당 운송 비용(단위: 수천 달러)'; \n"+

          " c(i,j) = f * d(i,j) / 1000 ; \n"+

          " \n"+

          "변수 \n"+

          " 케이스의 x(i,j) 배송 수량 \n"+

          " z 총 운송 비용(수천 달러) ; \n"+

          " \n"+

          "양수 변수 x; \n"+

          " \n"+

          "방정식 \n"+

          " 비용 '목적 함수 정의' \n"+

          " 공급(i) '공장 i의 공급 제한 준수' \n"+

          " 수요(j) '시장 j의 수요를 충족'; \n"+

          " \n"+

          "비용 .. z =e= sum((i,j), c(i,j)*x(i,j)) ; \n"+

          " \n"+

          "공급(i) .. 합계(j, x(i,j)) =l= a(i) ; \n"+

          " \n"+

          "수요(j) .. sum(i, x(i,j)) =g= bmult*b(j) ; \n"+

          " \n"+

          "모델 전송 /all/ ; \n"+

          " \n"+

          "z를 최소화하는 lp를 사용하여 전송을 해결합니다; \n"+

          " \n"+

          "스칼라 \n"+

          " ms '모델 상태' \n"+

          " ss '상태 해결'; \n"+

          " \n"+

          "x.l, x.m 표시; \n";

}


com::메가 슬롯::api::GAMSCheckpoint

com::메가 슬롯::api::GAMSDatabase

com::메가 슬롯::api::GAMSDatabase::getName
문자열 getName()

com::메가 슬롯::api::GAMSDatabase::getParameter
GAMSParameter getParameter(문자열 식별자)

com::메가 슬롯::api::GAMSDatabase::export
내보내기 무효()

com::메가 슬롯::api::GAMSDatabase::getVariable
GAMSVariable getVariable(문자열 식별자)

com::메가 슬롯::api::GAMSEngineConfiguration

com::메가 슬롯::api::GAMSEngineRunParameters::newBuilder

com::메가 슬롯::api::GAMSEngineRunParameters::newBuilder::setEngineOptions
newBuilder setEngineOptions(HashMap< 문자열, 문자열 > 옵션)

com::메가 슬롯::api::GAMSEngineRunParameters::newBuilder::setExtraModelFiles
newBuilder setExtraModelFiles(Set< String > modelFiles)

com::메가 슬롯::api::GAMSEngineRunParameters

com::메가 슬롯::api::GAMSException

com::메가 슬롯::api::GAMSException::getMessage
문자열 getMessage()

com::메가 슬롯::api::GAMSJob

com::메가 슬롯::api::GAMSJob::runEngine
void runEngine(GAMSEngineRunParameters 매개변수)

com::메가 슬롯::api::GAMSJob::OutDB
메가 슬롯데이터베이스 OutDB()

com::메가 슬롯::api::GAMSJob::인터럽트
부울 인터럽트()

com::메가 슬롯::api::GAMSOptions

com::메가 슬롯::api::GAMSOptions::setOptFile
void setOptFile(int x)

com::메가 슬롯::api::GAMSOptions::defines
void 정의(String defStr, String asStr)

com::메가 슬롯::api::GAMSOptions::setAllModelTypes
void setAllModelTypes(문자열 값)

com::메가 슬롯::api::GAMSOptions::setSolveLink
void setSolveLink(GAMSOptions.ESolveLink x)

com::메가 슬롯::api::GAMSOptions::dispose
무효 처리()

com::메가 슬롯::api::GAMSOptions::setMIP
void setMIP(문자열 x)

com::메가 슬롯::api::GAMSVariableRecord

com::메가 슬롯::api::GAMSWorkspaceInfo

com::메가 슬롯::api::GAMSWorkspaceInfo::setSystemDirectory
void setSystemDirectory(문자열 디렉토리)

com::메가 슬롯::api::GAMSWorkspaceInfo::setWorkingDirectory
void setWorkingDirectory(문자열 디렉토리)

com::메가 슬롯::api::GAMSWorkspace

com::메가 슬롯::api::GAMSWorkspace::addJobFromString
GAMSJob addJobFromString(문자열 소스)

com::메가 슬롯::api::GAMSWorkspace::workingDirectory
문자열 WorkingDirectory()

com::메가 슬롯::api::GAMSWorkspace::addCheckpoint
GAMSCheckpoint addCheckpoint()

com::메가 슬롯::api::GAMSWorkspace::addOptions
GAMSOptions addOptions()

com::메가 슬롯::api::GAMSWorkspace::addJobFromGamsLib
GAMSJob addJobFromGamsLib(문자열 모델 이름)

com::메가 슬롯::examples.transport.TransportEngine
이 예는 runEngine 메소드를 사용하여 메가 슬롯 엔진에서 GAMSJob을 실행하는 방법을 보여줍니다(메가 슬롯 44부터):
정의 TransportEngine.java:19

com::메가 슬롯::api

com::메가 슬롯

com