OptimJเป็นส่วนขยายสำหรับJavaที่รองรับภาษาสำหรับการเขียนแบบจำลองการเพิ่มประสิทธิภาพและนามธรรมสำหรับการประมวลผลข้อมูลจำนวนมาก ส่วนขยายและผลิตภัณฑ์ที่เป็นกรรมสิทธิ์ซึ่งนำส่วนขยายไปใช้ได้รับการพัฒนาโดย Ateji ซึ่งเลิกกิจการในเดือนกันยายน 2011 ^{[ 1 ]} OptimJ มีเป้าหมายที่จะนำเสนอสัญกรณ์พีชคณิตที่ชัดเจนและกระชับสำหรับการสร้างแบบจำลองการเพิ่มประสิทธิภาพ ขจัดอุปสรรคด้านความเข้ากันได้ระหว่างการสร้างแบบจำลองการเพิ่มประสิทธิภาพและเครื่องมือการเขียนโปรแกรมแอปพลิเคชัน และนำเทคนิควิศวกรรมซอฟต์แวร์ เช่น การวางแนวเชิงวัตถุและการสนับสนุน IDE ที่ทันสมัยมาสู่ผู้เชี่ยวชาญด้านการเพิ่มประสิทธิภาพ

โมเดล OptimJ สามารถใช้งานร่วมกับซอร์สโค้ด Java และไลบรารี Java ที่มีอยู่แล้วได้โดยตรง เช่น การเข้าถึงฐานข้อมูล การเชื่อมต่อ Excel หรือส่วนติดต่อผู้ใช้แบบกราฟิก OptimJ สามารถใช้งานร่วมกับเครื่องมือพัฒนาต่างๆ เช่น Eclipse, CVS, JUnit หรือ JavaDoc ได้ OptimJ สามารถใช้งานได้ฟรีกับตัวแก้ปัญหาต่อไปนี้: lp_solve, glpk, LP หรือ MPS และยังรองรับตัวแก้ปัญหาเชิงพาณิชย์ต่อไปนี้ด้วย: MOSEKและ IBM ILOG CPLEX Optimization Studio

OptimJ ผสานแนวคิดจากภาษาเชิงวัตถุแบบคำสั่งเข้ากับแนวคิดจากภาษาสร้างแบบจำลองเชิงพีชคณิตสำหรับปัญหาการหาค่าเหมาะสมที่สุด ในที่นี้เราจะทบทวนแนวคิดการหาค่าเหมาะสมที่สุดที่เพิ่มเข้ามาใน Java โดยเริ่มจากตัวอย่างที่เป็นรูปธรรม

เป้าหมายของ ปัญหา การระบายสีแผนที่คือการระบายสีแผนที่เพื่อให้บริเวณที่มีพรมแดนร่วมกันมีสีต่างกัน สามารถแสดงใน OptimJ ได้ดังนี้

ตัวอย่างแพ็กเกจ;// โมเดลอย่างง่ายสำหรับปัญหาการระบายสีแผนที่public model SimpleColoring solver lpsolve { // จำนวนสีสูงสุดint nbColors = 4 ;// ตัวแปรตัดสินใจเก็บสีของแต่ละประเทศvar int belgium in 1 .. nbColors ; var int denmark in 1 .. nbColors ; var int germany in 1 .. nbColors ;// ประเทศเพื่อนบ้านต้องมีสีที่แตกต่างกันข้อจำกัด{ เบลเยียม!= เยอรมนี; เยอรมนี!= เดนมาร์ก; }// จุดเริ่มต้นหลักในการทดสอบโมเดลของเราpublic static void main ( String [] args ) { // สร้างอินสแตนซ์ของโมเดลSimpleColoring m = new SimpleColoring ();// แก้ปัญหาm.extract ( ); m.solve ( );// พิมพ์คำตอบSystem.out.println ( " เบลเยียม: " + m.value ( m.belgium ) ) ; System.out.println ( " เดนมาร์ก: " + m.value ( m.denmark ) ) ; System.out.println ( " เยอรมนี: " + m.value ( m.germany ) ) ; } }​​​​​​

ผู้อ่านที่คุ้นเคยกับภาษา Java จะสังเกตเห็นความคล้ายคลึงกันอย่างมากกับภาษานี้ อันที่จริง OptimJ เป็นส่วนขยายที่อนุรักษ์นิยมของ Java: ทุกโปรแกรม Java ที่ถูกต้องก็เป็นโปรแกรม OptimJ ที่ถูกต้องเช่นกัน และมีพฤติกรรมเหมือนกัน

ตัวอย่างการระบายสีแผนที่นี้ยังแสดงคุณสมบัติเฉพาะของการเพิ่มประสิทธิภาพซึ่งไม่มีสิ่งที่เทียบเท่าโดยตรงใน Java ซึ่งนำเสนอโดยคำหลักmodel, var, constraints.

โมเดลคือส่วนขยายของคลาสในภาษา Java ที่สามารถประกอบด้วยฟิลด์และเมธอด รวมถึงข้อจำกัดและฟังก์ชันเป้าหมายได้ โดยจะใช้คีย์เวิร์ด ` model` ในการสร้าง modelโมเดลและปฏิบัติตามกฎเดียวกันกับการประกาศคลาส โมเดลที่ไม่ใช่แบบนามธรรมจะต้องเชื่อมโยงกับตัวแก้ปัญหา (solver) ซึ่งใช้คีย์เวิร์ด ` solversolver` ความสามารถของตัวแก้ปัญหาจะกำหนดว่าข้อจำกัดประเภทใดสามารถแสดงในโมเดลได้ ตัวอย่างเช่น ตัวแก้ปัญหาเชิงเส้น เช่น`lp solve`จะอนุญาตเฉพาะข้อจำกัดเชิงเส้นเท่านั้น

ตัวแก้ปัญหาSimpleColoring สาธารณะlpsolve

ภาษาโปรแกรมเชิงคำสั่ง เช่น Java มีแนวคิดเรื่องตัวแปรเชิงคำสั่งซึ่งโดยพื้นฐานแล้วหมายถึงตำแหน่งในหน่วยความจำที่สามารถเขียนและอ่านค่าได้

OptimJ ยังแนะนำแนวคิดของตัวแปรตัดสินใจ ซึ่งโดยพื้นฐานแล้วหมายถึงปริมาณที่ไม่ทราบค่าที่เรากำลังค้นหาค่าของมัน คำตอบของปัญหาการหาค่าที่เหมาะสมที่สุดคือชุดของค่าสำหรับตัวแปรตัดสินใจทั้งหมดที่สอดคล้องกับข้อจำกัดของปัญหา หากไม่มีตัวแปรตัดสินใจ ก็จะไม่สามารถแสดงปัญหาการหาค่าที่เหมาะสมที่สุดได้ คำว่า "ตัวแปรตัดสินใจ" มาจากชุมชนการหาค่าที่เหมาะสมที่สุด แต่ตัวแปรตัดสินใจใน OptimJ เป็นแนวคิดเดียวกับตัวแปรเชิงตรรกะในภาษาเชิงตรรกะ เช่น Prolog

ตัวแปรตัดสินใจมีประเภทพิเศษที่กำหนดโดยคำหลัก `type` varโดยจะมีvarประเภทสำหรับประเภทข้อมูลที่เป็นไปได้แต่ละประเภทในภาษา Java

// ตัวแปรประเภท var สำหรับประเภทข้อมูลพื้นฐานของ Java var int x ;// ตัวแปรประเภท var สำหรับคลาสที่ผู้ใช้กำหนดเองvar MyClass y ;

ในตัวอย่างการระบายสีแผนที่ ตัวแปรการตัดสินใจถูกนำเสนอพร้อมกับช่วงค่าที่ตัวแปรเหล่านั้นอาจมีได้

var int germany in 1 .. nbColors ;

นี่เป็นเพียงวิธีเขียนแบบย่อที่เทียบเท่ากับการกำหนดข้อจำกัดให้กับตัวแปร

ข้อจำกัดแสดงถึงเงื่อนไขที่ต้องเป็นจริงในทุกคำตอบของปัญหา ข้อจำกัดสามารถเป็นนิพจน์บูลีนใดๆ ในภาษาจาวาที่เกี่ยวข้องกับตัวแปรตัดสินใจได้

ในตัวอย่างการระบายสีแผนที่ ข้อจำกัดชุดนี้ระบุว่า ในคำตอบใดๆ ของปัญหาการระบายสีแผนที่ สีของเบลเยียมจะต้องแตกต่างจากสีของเยอรมนี และสีของเยอรมนีจะต้องแตกต่างจากสีของเดนมาร์ก

ข้อจำกัด{ เบลเยียม!= เยอรมนี; เยอรมนี!= เดนมาร์ก; }

ตัวดำเนินการนี้!=คือตัวดำเนินการไม่เท่ากับมาตรฐานของภาษา Java

ข้อจำกัดมักมาเป็นชุดๆ และสามารถกำหนดปริมาณได้ด้วยforallตัวดำเนินการ ตัวอย่างเช่น แทนที่จะแสดงรายการประเทศทั้งหมดและประเทศเพื่อนบ้านอย่างชัดเจนในซอร์สโค้ด เราอาจใช้อาร์เรย์ของประเทศ อาร์เรย์ของตัวแปรตัดสินใจที่แสดงสีของแต่ละประเทศ และอาร์เรย์boolean[][] neighboringหรือฟังก์ชันเชิงตรรกะ (ฟังก์ชันบูลีน) boolean isNeighbor()ก็ได้

ข้อจำกัด{ สำหรับประเทศทั้งหมดc1 : ประเทศต่างๆ, c2 : ประเทศต่างๆ, : เป็นเพื่อนบ้าน( c1 , c2 )) { สี[ c1 ] != สี[ c2 ] ; } }

Country c1 : countriesเป็นตัวสร้าง (generator): มันจะวนซ้ำไปc1เรื่อยๆ จนครบทุกค่าในคอลเลกcountriesชัน

:isNeighbor(c1,c2)เป็นตัวกรอง: มันจะเก็บเฉพาะค่าที่สร้างขึ้นซึ่งตรงตามเงื่อนไขที่กำหนด (สัญลักษณ์นี้:อาจอ่านได้ว่า "ถ้า")

สมมติว่าอาร์เรย์countriesประกอบด้วยbelgium, germanyและdenmarkและเงื่อนไขisNeighborส่งคืนค่าtrueสำหรับคู่ ( Belgium , Germany) และ ( Germany, Denmark) แล้วโค้ดนี้จะเทียบเท่ากับบล็อกข้อจำกัดของตัวอย่างการระบายสีแผนที่ดั้งเดิม

โดยทางเลือกแล้ว เมื่อแบบจำลองอธิบายถึงปัญหาการหาค่าที่เหมาะสมที่สุด อาจมีการระบุฟังก์ชันเป้าหมายที่จะต้องลดหรือเพิ่มให้มากที่สุดไว้ในแบบจำลองนั้นด้วย

แนวคิดทั่วไป (Generalist concepts) คือแนวคิดการเขียนโปรแกรมที่ไม่จำเพาะเจาะจงกับปัญหาการวิจัยดำเนินงาน (OR) และสามารถนำไปประยุกต์ใช้ได้ในการพัฒนาแอปพลิเคชันทุกประเภท แนวคิดทั่วไปที่เพิ่มเข้ามาใน Java โดย OptimJ ทำให้การแสดงแบบจำลอง OR ง่ายขึ้นหรือกระชับยิ่งขึ้น แนวคิดเหล่านี้มักพบได้ในภาษาสร้างแบบจำลองรุ่นเก่า ดังนั้นจึงช่วยให้ผู้เชี่ยวชาญด้าน OR สามารถแสดงแบบจำลองของตนได้อย่างคุ้นเคย

ในขณะที่อาร์เรย์ใน Java สามารถเข้าถึงได้ด้วยจำนวนเต็มที่เริ่มต้นที่ 0 เท่านั้น แต่อาร์เรย์ใน OptimJ สามารถเข้าถึงได้ด้วยค่าประเภทใดก็ได้ อาร์เรย์ดังกล่าวโดยทั่วไปเรียกว่าอาร์เรย์แบบเชื่อมโยงหรือแผนที่ ในตัวอย่างนี้ อาร์เรย์ageประกอบด้วยอายุของบุคคล โดยระบุด้วยชื่อของพวกเขา:

int [ String ] อายุ;

ชนิดint[String]ข้อมูลที่แสดงถึงอาร์เรย์intที่มีดัชนีเป็นString. การเข้าถึงอาร์เรย์ OptimJ โดยใช้ไวยากรณ์ Java มาตรฐาน:

อายุ[ "Stephan" ] = 37 ; x = อายุ[ "Lynda" ] ;

โดยทั่วไปแล้ว อาร์เรย์แบบเชื่อมโยงถูกนำมาใช้กันอย่างแพร่หลายในการแสดงปัญหาการหาค่าเหมาะสมที่สุด อาร์เรย์แบบเชื่อมโยงของ OptimJ มีประโยชน์มากเมื่อเชื่อมโยงกับไวยากรณ์การกำหนดค่าเริ่มต้นเฉพาะของมัน ค่าเริ่มต้นสามารถกำหนดได้ในคำจำกัดความเชิงเจตนาดังเช่น:

int [ String ] age = { "Stephan" -> 37 , "Lynda" -> 29 };

หรือสามารถให้ในรูปแบบนิยามเชิงขยายได้ เช่น:

int [ String ] length [ String name : names ] = name . length ();

ในที่นี้ แต่ละรายการlength[i]จะถูกกำหนดค่าเริ่มต้นด้วยnames[i].length().

ทูเพิล (Tuple)พบได้ทั่วไปในด้านการคำนวณ แต่กลับไม่มีอยู่ในภาษาโปรแกรมหลักส่วนใหญ่ รวมถึง Java ด้วย OptimJ จึงนำเสนอแนวคิดของทูเพิลในระดับภาษา ซึ่งมีประโยชน์อย่างมากในการใช้เป็นดัชนีร่วมกับอาร์เรย์แบบเชื่อมโยง (associative array)

(: int , String :) myTuple = new (: 3 , "Three" :); String s = myTuple # 1 ;

ทั้งชนิดข้อมูลทูเพิลและค่าทูเพิลจะเขียนอยู่ระหว่างเครื่องหมายจุลภาค(:และ เครื่องหมาย :)จุลภาค

Comprehensionsหรือที่เรียกว่าการดำเนินการรวมหรือการลดรูป คือนิพจน์ OptimJ ที่ขยายการดำเนินการไบนารีที่กำหนดให้กับชุดของค่า ตัวอย่างที่พบได้ทั่วไปคือการบวก:

// ผลรวมของจำนวนเต็มทั้งหมดตั้งแต่ 1 ถึง 10 int k = sum { i | int i in 1 .. 10 };

โครงสร้างนี้คล้ายคลึงกับ สัญลักษณ์ การหาผลรวม แบบบิ๊กซิกมา ที่ใช้ในคณิตศาสตร์ โดยมีไวยากรณ์ที่เข้ากันได้กับภาษาจาวา

นอกจากนี้ ยังสามารถใช้ Comprehensions ในการสร้างชุดข้อมูลต่างๆ เช่น รายการ เซต มัลติเซต หรือแผนที่ได้อีกด้วย:

// เซตของจำนวนเต็มทั้งหมดตั้งแต่ 1 ถึง 10 HashSet < Integer > s = ` hashSet (){ i | int i in 1 .. 10 };

สำนวนแสดงความเข้าใจสามารถมีสำนวนใดๆ ก็ได้เป็นเป้าหมาย ดังเช่น:

// ผลรวมของกำลังสองของจำนวนเต็มทั้งหมดตั้งแต่ 1 ถึง 10 int k = sum { i * i | int i in 1 .. 10 };

นอกจากนี้ พวกมันยังสามารถมีตัวสร้างและตัวกรองจำนวนเท่าใดก็ได้:

// ผลรวมของ f(i,j) ทั้งหมด สำหรับ 0<=i<10, 1<=j<=10 และ i!=j int k = sum { f ( i , j ) | int i : 10 , int j : 1 .. 10 , : i != j }

การสร้างโครงสร้างข้อมูลแบบเข้าใจง่าย (Comprehension) ไม่จำเป็นต้องใช้กับค่าตัวเลขเท่านั้น การสร้างโครงสร้างข้อมูลแบบเซตหรือมัลติเซต โดยเฉพาะอย่างยิ่งเมื่อใช้ร่วมกับทูเปิลของสตริง จะทำให้สามารถแสดงคำสั่งค้นหาที่คล้ายกับคำสั่งค้นหาในฐานข้อมูล SQL ได้:

// เลือกชื่อจากตาราง persons ที่อายุมากกว่า 18 ปี` multiSet (){ p . name | Person p : persons , : p . age > 18 }

ในบริบทของแบบจำลองการปรับให้เหมาะสม นิพจน์ความเข้าใจ (comprehension expressions) เป็นวิธีที่กระชับและสื่อความหมายได้ดีในการประมวลผลล่วงหน้าและทำความสะอาดข้อมูลขาเข้า รวมถึงจัดรูปแบบข้อมูลขาออก

OptimJ มีให้ใช้งานในรูปแบบปลั๊กอินของ Eclipse คอมไพเลอร์นี้ทำการแปลงโค้ดต้นฉบับจาก OptimJ ไปเป็น Java มาตรฐาน ทำให้สามารถใช้งานร่วมกับเครื่องมือพัฒนาส่วนใหญ่ในระบบนิเวศของ Java ได้ทันที

เนื่องจากคอมไพเลอร์ OptimJ รู้จักโครงสร้างของข้อมูลทั้งหมดที่ใช้ในโมเดล จึงสามารถสร้างมุมมองกราฟิกที่มีโครงสร้างของข้อมูลนี้ได้ในระหว่างการคอมไพล์ ซึ่งมีความสำคัญอย่างยิ่งในกรณีของอาร์เรย์แบบเชื่อมโยง (associative arrays) ที่คอมไพเลอร์รู้จักคอลเลกชันที่ใช้สำหรับการทำดัชนีมิติต่างๆ

รูปแบบกราฟิกพื้นฐานที่สร้างโดยคอมไพเลอร์นั้นคล้ายคลึงกับคิวบ์ OLAPจากนั้นสามารถปรับแต่งได้หลายวิธี ตั้งแต่การระบายสีอย่างง่ายไปจนถึงการเพิ่มวิดเจ็ตใหม่สำหรับการแสดงองค์ประกอบข้อมูล

ส่วนต่อประสานผู้ใช้แบบกราฟิก (GUI) ของ OptimJ ที่สร้างโดยคอมไพเลอร์ ช่วยให้ผู้เชี่ยวชาญด้านการวิจัยดำเนินงาน (OR) ไม่ต้องเขียนโค้ดเชื่อมต่อทั้งหมดที่จำเป็นเมื่อแมปไลบรารีแบบกราฟิกเข้ากับข้อมูล ช่วยให้สามารถสร้างต้นแบบได้อย่างรวดเร็ว โดยให้คำแนะนำเชิงภาพเกี่ยวกับโครงสร้างของข้อมูลได้ทันที

ส่วนอื่นของ GUI ของ OptimJ แสดงสถิติประสิทธิภาพแบบเรียลไทม์จากตัวแก้ปัญหา ข้อมูลนี้สามารถใช้เพื่อทำความเข้าใจปัญหาด้านประสิทธิภาพและปรับปรุงเวลาในการแก้ปัญหา ปัจจุบันมีให้ใช้งานเฉพาะสำหรับ lp_solve เท่านั้น

OptimJ สามารถใช้งานได้ฟรีกับไฟล์รูปแบบ lp_solve, glpk, LP หรือ MPS และยังรองรับโปรแกรมแก้ปัญหาเชิงพาณิชย์ต่อไปนี้ด้วย: Mosek, IBM ILOG และ CPLEX Optimization Studio

• การสร้างแบบจำลองเชิงวัตถุด้วย OptimJ
• คู่มือภาษา OptimJ
• OptimJ GUI