From 919d4a1006748d9ffcc67c6da0f59bbf215ece17 Mon Sep 17 00:00:00 2001 From: "Yann Esposito (Yogsototh)" Date: Tue, 17 May 2011 22:24:18 +0200 Subject: [PATCH] Initial git init in the future I may add the SVN history --- .DS_Store | Bin 0 -> 12292 bytes .gitignore | 1 + apprend.sh | 37 + dees | 1 + dees.xcodeproj/esposito.mode1 | 1432 +++++++++++++++++ dees.xcodeproj/esposito.pbxuser | 751 +++++++++ dees.xcodeproj/project.pbxproj | 318 ++++ general.H | 135 ++ help/help.txt | 39 + include/declare.h | 22 + include/fortify.h | 183 +++ include/ini.h | 9 + include/lp_Hash.h | 43 + include/lp_MDO.h | 18 + include/lp_MPS.h | 37 + include/lp_SOS.h | 108 ++ include/lp_crash.h | 29 + include/lp_explicit.h | 1016 ++++++++++++ include/lp_fortify.h | 5 + include/lp_lib.h | 2266 +++++++++++++++++++++++++++ include/lp_matrix.h | 257 ++++ include/lp_mipbb.h | 64 + include/lp_presolve.h | 126 ++ include/lp_price.h | 99 ++ include/lp_pricePSE.h | 28 + include/lp_report.h | 42 + include/lp_rlp.h | 1901 +++++++++++++++++++++++ include/lp_scale.h | 31 + include/lp_simplex.h | 34 + include/lp_solveDLL.h | 24 + include/lp_types.h | 326 ++++ include/lp_utils.h | 159 ++ include/lp_wlp.h | 21 + include/lpkit.h | 32 + include/lpsolve.h | 24 + include/ufortify.h | 63 + include/yacc_read.h | 24 + interface.H | 5 + interface.cpp | 695 +++++++++ lib/liblpsolve55.a | Bin 0 -> 857640 bytes lib/liblpsolve55.dylib | Bin 0 -> 585048 bytes lib/linux_liblpsolve55.a | Bin 0 -> 654572 bytes ma.H | 278 ++++ ma.cpp | 2562 +++++++++++++++++++++++++++++++ main.H | 34 + main.cpp | 1324 ++++++++++++++++ oldsimplex.H | 31 + pfa.H | 112 ++ pfa.cpp | 713 +++++++++ pprfa.H | 179 +++ pprfa.cpp | 339 ++++ pprfa_bm.cpp | 422 +++++ pprfa_dees.cpp | 536 +++++++ sample.H | 203 +++ sample.cpp | 762 +++++++++ simplex.H | 77 + simplex.cpp | 196 +++ spfa.H | 168 ++ spfa.cpp | 1284 ++++++++++++++++ test.H | 13 + test.cpp | 92 ++ toto | 0 ySimplex.cpp | 365 +++++ 63 files changed, 20095 insertions(+) create mode 100644 .DS_Store create mode 100644 .gitignore create mode 100755 apprend.sh create mode 120000 dees create mode 100644 dees.xcodeproj/esposito.mode1 create mode 100644 dees.xcodeproj/esposito.pbxuser create mode 100644 dees.xcodeproj/project.pbxproj create mode 100644 general.H create mode 100644 help/help.txt create mode 100644 include/declare.h create mode 100644 include/fortify.h create mode 100644 include/ini.h create mode 100644 include/lp_Hash.h create mode 100644 include/lp_MDO.h create mode 100644 include/lp_MPS.h create mode 100644 include/lp_SOS.h create mode 100644 include/lp_crash.h create mode 100644 include/lp_explicit.h create mode 100644 include/lp_fortify.h create mode 100644 include/lp_lib.h create mode 100644 include/lp_matrix.h create mode 100644 include/lp_mipbb.h create mode 100644 include/lp_presolve.h create mode 100644 include/lp_price.h create mode 100644 include/lp_pricePSE.h create mode 100644 include/lp_report.h create mode 100644 include/lp_rlp.h create mode 100644 include/lp_scale.h create mode 100644 include/lp_simplex.h create mode 100644 include/lp_solveDLL.h create mode 100644 include/lp_types.h create mode 100644 include/lp_utils.h create mode 100644 include/lp_wlp.h create mode 100644 include/lpkit.h create mode 100644 include/lpsolve.h create mode 100644 include/ufortify.h create mode 100644 include/yacc_read.h create mode 100644 interface.H create mode 100644 interface.cpp create mode 100644 lib/liblpsolve55.a create mode 100755 lib/liblpsolve55.dylib create mode 100644 lib/linux_liblpsolve55.a create mode 100644 ma.H create mode 100644 ma.cpp create mode 100644 main.H create mode 100644 main.cpp create mode 100644 oldsimplex.H create mode 100644 pfa.H create mode 100644 pfa.cpp create mode 100644 pprfa.H create mode 100644 pprfa.cpp create mode 100644 pprfa_bm.cpp create mode 100644 pprfa_dees.cpp create mode 100644 sample.H create mode 100644 sample.cpp create mode 100644 simplex.H create mode 100644 simplex.cpp create mode 100644 spfa.H create mode 100644 spfa.cpp create mode 100644 test.H create mode 100644 test.cpp create mode 100644 toto create mode 100644 ySimplex.cpp diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..a4faf749a84dbe41df8ceba42098ec4bc7501a90 GIT binary patch literal 12292 zcmeI1&raJw5XNT{Cpbh@Tq?oM9D70H(7T1GRL;Fss?;XoPb5R20f`HeFMWVML?5CL z(Ff>5^cmzrCqso$dAan|3=j(^_7Od=xg@OE|}vLhlny4vkAhD6iz+FPv` zXLey7{N=b>OefW1g4f$EH77`b1W14cNPqEaN_6^7WUw_y_Ct%BH>tHd1=7KA1aCNc7aItc5!5!zzsIP+!?&AE) zh!af}A*{WQ7_nIrBL%3IB)t#+@w)wAWank*KT=D6hp-S`wwk>nId z`xviMDY&mD=s4+_xWGm#eWW~>Nh0B2CU#WWM2B*L^g2`PeKYP^)TWZLmymm%l1#>R zxSxGz;)Wc8J{8+u!Uhm3(C*0JP2|B!orv2zHp-FS8tkXFv9lk>Lo<2wNX578Hf4#d zFW^zF+X{nMW`+ET&yzKD_x3*+{TTZBYK^;YMvYZQEw9u%ma68p<}PSngD)npq0uK| zXD^L57k$$#F(&V@#?G#derWXP&F!!I%xX)0W8$%02g~Qba$qBY=O)k(3G8V7|EBx< z|L0DV>yrQp{6zvTJ9>9?hy`M8-C9a(?E?KHx;E9-!Fm@Az8r`32SXeekg87^ rZ5=FT(D+4w$H0LENPq-LfCNZ@1W14cNPq-LfCNZ@1W14c{wRUp8#6y# literal 0 HcmV?d00001 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..90ec22b --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.svn diff --git a/apprend.sh b/apprend.sh new file mode 100755 index 0000000..ff45a1a --- /dev/null +++ b/apprend.sh @@ -0,0 +1,37 @@ +#! /bin/bash + +if [ $# -lt 3 ]; then + echo "utilisation : $0 fichier_automate nombre_d_essais nombre_de_base [nb_repetitions]" + exit -1 +fi + +options="-v -p .5 --maxmots 10" +# options="-v -p .2" + +if [ $# -gt 3 ]; then + nombre_repetitions=$4 +else + nombre_repetitions=1 +fi + +cible=$1 +name=`basename $cible` +svgrep="test/svg" + +dist=$svgrep/dist-$name +cat /dev/null > $dist +k=1 +while [ $k -le $2 ]; do + i=$(( $k * $3 )) + realTaille=$(( $i * $2 )) + for j in `seq $nombre_repetitions`; do + id=$name-$realTaille-$j + sample=$svgrep/sample-$id + log=$svgrep/log-$id + ma=$svgrep/ma-$id.ma + ./dees --sample $cible $realTaille $sample + ./dees --deesha $options -o $ma $sample > $log + ./dees --dist $cible $ma >> $dist 2>/dev/null + done + k=$(( $k + 1 )) +done diff --git a/dees b/dees new file mode 120000 index 0000000..92b3278 --- /dev/null +++ b/dees @@ -0,0 +1 @@ +build/Debug/dees \ No newline at end of file diff --git a/dees.xcodeproj/esposito.mode1 b/dees.xcodeproj/esposito.mode1 new file mode 100644 index 0000000..34b8a90 --- /dev/null +++ b/dees.xcodeproj/esposito.mode1 @@ -0,0 +1,1432 @@ + + + + + ActivePerspectiveName + Project + AllowedModules + + + BundleLoadPath + + MaxInstances + n + Module + PBXSmartGroupTreeModule + Name + Groups and Files Outline View + + + BundleLoadPath + + MaxInstances + n + Module + PBXNavigatorGroup + Name + Editor + + + BundleLoadPath + + MaxInstances + n + Module + XCTaskListModule + Name + Task List + + + BundleLoadPath + + MaxInstances + n + Module + XCDetailModule + Name + File and Smart Group Detail Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXBuildResultsModule + Name + Detailed Build Results Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXProjectFindModule + Name + Project Batch Find Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXRunSessionModule + Name + Run Log + + + BundleLoadPath + + MaxInstances + n + Module + PBXBookmarksModule + Name + Bookmarks Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXClassBrowserModule + Name + Class Browser + + + BundleLoadPath + + MaxInstances + n + Module + PBXCVSModule + Name + Source Code Control Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXDebugBreakpointsModule + Name + Debug Breakpoints Tool + + + BundleLoadPath + + MaxInstances + n + Module + XCDockableInspector + Name + Inspector + + + BundleLoadPath + + MaxInstances + n + Module + PBXOpenQuicklyModule + Name + Open Quickly Tool + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugSessionModule + Name + Debugger + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugCLIModule + Name + Debug Console + + + Description + DefaultDescriptionKey + DockingSystemVisible + + Extension + mode1 + FavBarConfig + + PBXProjectModuleGUID + F878A30809F3A37400225D95 + XCBarModuleItemNames + + XCBarModuleItems + + + FirstTimeWindowDisplayed + + Identifier + com.apple.perspectives.project.mode1 + MajorVersion + 31 + MinorVersion + 1 + Name + Default + Notifications + + OpenEditors + + PerspectiveWidths + + -1 + -1 + + Perspectives + + + ChosenToolbarItems + + active-target-popup + action + NSToolbarFlexibleSpaceItem + buildOrClean + build-and-runOrDebug + com.apple.ide.PBXToolbarStopButton + get-info + toggle-editor + NSToolbarFlexibleSpaceItem + com.apple.pbx.toolbar.searchfield + + ControllerClassBaseName + + IconName + WindowOfProjectWithEditor + Identifier + perspective.project + IsVertical + + Layout + + + BecomeActive + + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C37FBAC04509CD000000102 + 1C37FAAC04509CD000000102 + 1C08E77C0454961000C914BD + 1C37FABC05509CD000000102 + 1C37FABC05539CD112110102 + E2644B35053B69B200211256 + 1C37FABC04509CD000100104 + 1CC0EA4004350EF90044410B + 1CC0EA4004350EF90041110B + + PBXProjectModuleGUID + 1CE0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + yes + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 186 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 08FB7794FE84155DC02AAC07 + F878A31209F3A46500225D95 + F878A31109F3A45600225D95 + F878A31009F3A44A00225D95 + 08FB7795FE84155DC02AAC07 + 1C37FAAC04509CD000000102 + 1C37FABC05509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 7 + 5 + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {186, 602}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + + XCSharingToken + com.apple.Xcode.GFSharingToken + + GeometryConfiguration + + Frame + {{0, 0}, {203, 620}} + GroupTreeTableConfiguration + + MainColumn + 186 + + RubberWindowFrame + 0 85 987 661 0 0 1024 746 + + Module + PBXSmartGroupTreeModule + Proportion + 203pt + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CE0B20306471E060097A5F4 + PBXProjectModuleLabel + spfa.H + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CE0B20406471E060097A5F4 + PBXProjectModuleLabel + spfa.H + _historyCapacity + 0 + bookmark + F844881B0C0B4B5000D2870A + history + + F860B0CA09F40B5F0027FF1E + F876431509F7F5E500BAAC93 + F8B74EFF09F9512000D55E52 + F8F48D780A243553009DE375 + F8F48D790A243553009DE375 + F8F48D7B0A243553009DE375 + F8F48D7C0A243553009DE375 + F8F48D7D0A243553009DE375 + F8F48D7F0A243553009DE375 + F8F48D800A243553009DE375 + F8F48D810A243553009DE375 + F8D16C060A2517DD00264622 + F8D93E540B8EE67900D2768C + F896E5800BFB0BC400C659C6 + F896E5810BFB0BC400C659C6 + F896E5820BFB0BC400C659C6 + F896E5830BFB0BC400C659C6 + F896E5840BFB0BC400C659C6 + F84488190C0B4B5000D2870A + F896E5850BFB0BC400C659C6 + + prevStack + + F860B02609F402D50027FF1E + F860B02709F402D50027FF1E + F860B03109F402D50027FF1E + F860B03609F402D50027FF1E + F860B03C09F402D50027FF1E + F860B0D109F40B5F0027FF1E + F860B0D309F40B5F0027FF1E + F860B0D409F40B5F0027FF1E + F860B0D509F40B5F0027FF1E + F860B0D609F40B5F0027FF1E + F860B0D809F40B5F0027FF1E + F80E92B009F4496F00850979 + F80E92B109F4496F00850979 + F80E92B309F4496F00850979 + F871D10509F4E5D7001A8E9E + F871D17609F4F4A6001A8E9E + F871D17709F4F4A6001A8E9E + F871D17F09F4F4A6001A8E9E + F8A1460C09F7E54200584BA4 + F896E5880BFB0BC400C659C6 + F844881A0C0B4B5000D2870A + + + SplitCount + 1 + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {779, 423}} + RubberWindowFrame + 0 85 987 661 0 0 1024 746 + + Module + PBXNavigatorGroup + Proportion + 423pt + + + ContentConfiguration + + PBXProjectModuleGUID + 1CE0B20506471E060097A5F4 + PBXProjectModuleLabel + Detail + + GeometryConfiguration + + Frame + {{0, 428}, {779, 192}} + RubberWindowFrame + 0 85 987 661 0 0 1024 746 + + Module + XCDetailModule + Proportion + 192pt + + + Proportion + 779pt + + + Name + Project + ServiceClasses + + XCModuleDock + PBXSmartGroupTreeModule + XCModuleDock + PBXNavigatorGroup + XCDetailModule + + TableOfContents + + F84488170C0AF8E600D2870A + 1CE0B1FE06471DED0097A5F4 + F84488180C0AF8E600D2870A + 1CE0B20306471E060097A5F4 + 1CE0B20506471E060097A5F4 + + ToolbarConfiguration + xcode.toolbar.config.default + + + ControllerClassBaseName + + IconName + WindowOfProject + Identifier + perspective.morph + IsVertical + 0 + Layout + + + BecomeActive + 1 + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C37FBAC04509CD000000102 + 1C37FAAC04509CD000000102 + 1C08E77C0454961000C914BD + 1C37FABC05509CD000000102 + 1C37FABC05539CD112110102 + E2644B35053B69B200211256 + 1C37FABC04509CD000100104 + 1CC0EA4004350EF90044410B + 1CC0EA4004350EF90041110B + + PBXProjectModuleGUID + 11E0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + yes + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 186 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 29B97314FDCFA39411CA2CEA + 1C37FABC05509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {186, 337}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + 1 + XCSharingToken + com.apple.Xcode.GFSharingToken + + GeometryConfiguration + + Frame + {{0, 0}, {203, 355}} + GroupTreeTableConfiguration + + MainColumn + 186 + + RubberWindowFrame + 373 269 690 397 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 100% + + + Name + Morph + PreferredWidth + 300 + ServiceClasses + + XCModuleDock + PBXSmartGroupTreeModule + + TableOfContents + + 11E0B1FE06471DED0097A5F4 + + ToolbarConfiguration + xcode.toolbar.config.default.short + + + PerspectivesBarVisible + + ShelfIsVisible + + SourceDescription + file at '/System/Library/PrivateFrameworks/DevToolsInterface.framework/Versions/A/Resources/XCPerspectivesSpecificationMode1.xcperspec' + StatusbarIsVisible + + TimeStamp + 0.0 + ToolbarDisplayMode + 1 + ToolbarIsVisible + + ToolbarSizeMode + 1 + Type + Perspectives + UpdateMessage + The Default Workspace in this version of Xcode now includes support to hide and show the detail view (what has been referred to as the "Metro-Morph" feature). You must discard your current Default Workspace settings and update to the latest Default Workspace in order to gain this feature. Do you wish to update to the latest Workspace defaults for project '%@'? + WindowJustification + 5 + WindowOrderList + + /Users/esposito/Projets/dees/dees.xcodeproj + + WindowString + 0 85 987 661 0 0 1024 746 + WindowTools + + + FirstTimeWindowDisplayed + + Identifier + windowTool.build + IsVertical + + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528F0623707200166675 + PBXProjectModuleLabel + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {1024, 535}} + RubberWindowFrame + 0 60 1024 686 0 0 1024 746 + + Module + PBXNavigatorGroup + Proportion + 535pt + + + ContentConfiguration + + PBXProjectModuleGUID + XCMainBuildResultsModuleGUID + PBXProjectModuleLabel + Build + XCBuildResultsTrigger_Collapse + 1021 + XCBuildResultsTrigger_Open + 1011 + + GeometryConfiguration + + Frame + {{0, 540}, {1024, 105}} + RubberWindowFrame + 0 60 1024 686 0 0 1024 746 + + Module + PBXBuildResultsModule + Proportion + 105pt + + + Proportion + 645pt + + + Name + Build Results + ServiceClasses + + PBXBuildResultsModule + + StatusbarIsVisible + + TableOfContents + + F89BE30609F3A64D008C3386 + F8D16C0D0A2517DD00264622 + 1CD0528F0623707200166675 + XCMainBuildResultsModuleGUID + + ToolbarConfiguration + xcode.toolbar.config.build + WindowString + 0 60 1024 686 0 0 1024 746 + WindowToolGUID + F89BE30609F3A64D008C3386 + WindowToolIsVisible + + + + FirstTimeWindowDisplayed + + Identifier + windowTool.debugger + IsVertical + + Layout + + + Dock + + + ContentConfiguration + + Debugger + + HorizontalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {383, 213}} + {{383, 0}, {498, 213}} + + + VerticalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {881, 213}} + {{0, 213}, {881, 298}} + + + + LauncherConfigVersion + 8 + PBXProjectModuleGUID + 1C162984064C10D400B95A72 + PBXProjectModuleLabel + Debug - GLUTExamples (Underwater) + + GeometryConfiguration + + DebugConsoleDrawerSize + {100, 120} + DebugConsoleVisible + None + DebugConsoleWindowFrame + {{200, 200}, {500, 300}} + DebugSTDIOWindowFrame + {{200, 200}, {500, 300}} + Frame + {{0, 0}, {881, 511}} + RubberWindowFrame + 68 147 881 552 0 0 1024 746 + + Module + PBXDebugSessionModule + Proportion + 511pt + + + Proportion + 511pt + + + Name + Debugger + ServiceClasses + + PBXDebugSessionModule + + StatusbarIsVisible + + TableOfContents + + 1CD10A99069EF8BA00B06720 + F871D19009F4F510001A8E9E + 1C162984064C10D400B95A72 + F871D19109F4F510001A8E9E + F871D19209F4F510001A8E9E + F871D19309F4F510001A8E9E + F871D19409F4F510001A8E9E + F871D19509F4F510001A8E9E + F871D19609F4F510001A8E9E + + ToolbarConfiguration + xcode.toolbar.config.debug + WindowString + 68 147 881 552 0 0 1024 746 + WindowToolGUID + 1CD10A99069EF8BA00B06720 + WindowToolIsVisible + + + + Identifier + windowTool.find + Layout + + + Dock + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CDD528C0622207200134675 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CD0528D0623707200166675 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {781, 167}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXNavigatorGroup + Proportion + 781pt + + + Proportion + 50% + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528E0623707200166675 + PBXProjectModuleLabel + Project Find + + GeometryConfiguration + + Frame + {{8, 0}, {773, 254}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXProjectFindModule + Proportion + 50% + + + Proportion + 428pt + + + Name + Project Find + ServiceClasses + + PBXProjectFindModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C530D57069F1CE1000CFCEE + 1C530D58069F1CE1000CFCEE + 1C530D59069F1CE1000CFCEE + 1CDD528C0622207200134675 + 1C530D5A069F1CE1000CFCEE + 1CE0B1FE06471DED0097A5F4 + 1CD0528E0623707200166675 + + WindowString + 62 385 781 470 0 0 1440 878 + WindowToolGUID + 1C530D57069F1CE1000CFCEE + WindowToolIsVisible + 0 + + + Identifier + MENUSEPARATOR + + + FirstTimeWindowDisplayed + + Identifier + windowTool.debuggerConsole + IsVertical + + Layout + + + Dock + + + BecomeActive + + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAAC065D492600B07095 + PBXProjectModuleLabel + Debugger Console + + GeometryConfiguration + + Frame + {{0, 0}, {440, 358}} + RubberWindowFrame + 42 300 440 400 0 0 1024 746 + + Module + PBXDebugCLIModule + Proportion + 358pt + + + Proportion + 359pt + + + Name + Debugger Console + ServiceClasses + + PBXDebugCLIModule + + StatusbarIsVisible + + TableOfContents + + F871D19709F4F510001A8E9E + F871D19809F4F510001A8E9E + 1C78EAAC065D492600B07095 + + WindowString + 42 300 440 400 0 0 1024 746 + WindowToolGUID + F871D19709F4F510001A8E9E + WindowToolIsVisible + + + + FirstTimeWindowDisplayed + + Identifier + windowTool.run + IsVertical + + Layout + + + Dock + + + ContentConfiguration + + LauncherConfigVersion + 3 + PBXProjectModuleGUID + 1CD0528B0623707200166675 + PBXProjectModuleLabel + Run + Runner + + HorizontalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {367, 168}} + {{0, 173}, {367, 270}} + + + VerticalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {406, 443}} + {{411, 0}, {517, 443}} + + + + + GeometryConfiguration + + Frame + {{0, 0}, {459, 159}} + RubberWindowFrame + 89 476 459 200 0 0 1024 746 + + Module + PBXRunSessionModule + Proportion + 159pt + + + Proportion + 159pt + + + Name + Run Log + ServiceClasses + + PBXRunSessionModule + + StatusbarIsVisible + + TableOfContents + + 1C0AD2B3069F1EA900FABCE6 + F871D1A609F503B3001A8E9E + 1CD0528B0623707200166675 + F871D1A709F503B3001A8E9E + + ToolbarConfiguration + xcode.toolbar.config.run + WindowString + 89 476 459 200 0 0 1024 746 + WindowToolGUID + 1C0AD2B3069F1EA900FABCE6 + WindowToolIsVisible + + + + Identifier + windowTool.scm + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAB2065D492600B07095 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1C78EAB3065D492600B07095 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {452, 0}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + + Module + PBXNavigatorGroup + Proportion + 0pt + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1CD052920623707200166675 + PBXProjectModuleLabel + SCM + + GeometryConfiguration + + ConsoleFrame + {{0, 259}, {452, 0}} + Frame + {{0, 7}, {452, 259}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + TableConfiguration + + Status + 30 + FileName + 199 + Path + 197.09500122070312 + + TableFrame + {{0, 0}, {452, 250}} + + Module + PBXCVSModule + Proportion + 262pt + + + Proportion + 266pt + + + Name + SCM + ServiceClasses + + PBXCVSModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C78EAB4065D492600B07095 + 1C78EAB5065D492600B07095 + 1C78EAB2065D492600B07095 + 1CD052920623707200166675 + + ToolbarConfiguration + xcode.toolbar.config.scm + WindowString + 743 379 452 308 0 0 1280 1002 + + + Identifier + windowTool.breakpoints + IsVertical + 0 + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C77FABC04509CD000000102 + + PBXProjectModuleGUID + 1CE0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + no + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 168 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 1C77FABC04509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {168, 350}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + 0 + + GeometryConfiguration + + Frame + {{0, 0}, {185, 368}} + GroupTreeTableConfiguration + + MainColumn + 168 + + RubberWindowFrame + 315 424 744 409 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 185pt + + + ContentConfiguration + + PBXProjectModuleGUID + 1CA1AED706398EBD00589147 + PBXProjectModuleLabel + Detail + + GeometryConfiguration + + Frame + {{190, 0}, {554, 368}} + RubberWindowFrame + 315 424 744 409 0 0 1440 878 + + Module + XCDetailModule + Proportion + 554pt + + + Proportion + 368pt + + + MajorVersion + 2 + MinorVersion + 0 + Name + Breakpoints + ServiceClasses + + PBXSmartGroupTreeModule + XCDetailModule + + StatusbarIsVisible + 1 + TableOfContents + + 1CDDB66807F98D9800BB5817 + 1CDDB66907F98D9800BB5817 + 1CE0B1FE06471DED0097A5F4 + 1CA1AED706398EBD00589147 + + ToolbarConfiguration + xcode.toolbar.config.breakpoints + WindowString + 315 424 744 409 0 0 1440 878 + WindowToolGUID + 1CDDB66807F98D9800BB5817 + WindowToolIsVisible + 1 + + + FirstTimeWindowDisplayed + + Identifier + windowTool.debugAnimator + IsVertical + + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + F871D19C09F4F52D001A8E9E + PBXProjectModuleLabel + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {700, 459}} + RubberWindowFrame + 42 200 700 500 0 0 1024 746 + + Module + PBXNavigatorGroup + Proportion + 459pt + + + Proportion + 459pt + + + Name + Debug Visualizer + ServiceClasses + + PBXNavigatorGroup + + StatusbarIsVisible + + TableOfContents + + F871D19E09F4F52D001A8E9E + F871D19F09F4F52D001A8E9E + F871D19C09F4F52D001A8E9E + + ToolbarConfiguration + xcode.toolbar.config.debugAnimator + WindowString + 42 200 700 500 0 0 1024 746 + WindowToolGUID + F871D19E09F4F52D001A8E9E + WindowToolIsVisible + + + + Identifier + windowTool.bookmarks + Layout + + + Dock + + + Module + PBXBookmarksModule + Proportion + 100% + + + Proportion + 100% + + + Name + Bookmarks + ServiceClasses + + PBXBookmarksModule + + StatusbarIsVisible + 0 + WindowString + 538 42 401 187 0 0 1280 1002 + + + FirstTimeWindowDisplayed + + Identifier + windowTool.classBrowser + IsVertical + + Layout + + + Dock + + + ContentConfiguration + + OptionsSetName + Hierarchy, all classes + PBXProjectModuleGUID + 1CA6456E063B45B4001379D8 + PBXProjectModuleLabel + Class Browser - MA + + GeometryConfiguration + + ClassesFrame + {{0, 0}, {378, 96}} + ClassesTreeTableConfiguration + + PBXClassNameColumnIdentifier + 208 + PBXClassBookColumnIdentifier + 22 + + Frame + {{0, 0}, {630, 332}} + MembersFrame + {{0, 101}, {378, 231}} + MembersTreeTableConfiguration + + PBXMemberTypeIconColumnIdentifier + 22 + PBXMemberNameColumnIdentifier + 216 + PBXMemberTypeColumnIdentifier + 101 + PBXMemberBookColumnIdentifier + 22 + + RubberWindowFrame + 21 371 630 352 0 0 1024 746 + + Module + PBXClassBrowserModule + Proportion + 332pt + + + Proportion + 332pt + + + Name + Class Browser + ServiceClasses + + PBXClassBrowserModule + + StatusbarIsVisible + + TableOfContents + + 1C0AD2AF069F1E9B00FABCE6 + F8F48D6C0A2433FC009DE375 + 1CA6456E063B45B4001379D8 + + ToolbarConfiguration + xcode.toolbar.config.classbrowser + WindowString + 21 371 630 352 0 0 1024 746 + WindowToolGUID + 1C0AD2AF069F1E9B00FABCE6 + WindowToolIsVisible + + + + + diff --git a/dees.xcodeproj/esposito.pbxuser b/dees.xcodeproj/esposito.pbxuser new file mode 100644 index 0000000..c9b6237 --- /dev/null +++ b/dees.xcodeproj/esposito.pbxuser @@ -0,0 +1,751 @@ +// !$*UTF8*$! +{ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + activeBuildConfigurationName = Debug; + activeExecutable = F878A30309F3A36A00225D95 /* dees */; + activeTarget = 8DD76F620486A84900D96B5E /* dees */; + addToTargets = ( + 8DD76F620486A84900D96B5E /* dees */, + ); + codeSenseManager = F878A30A09F3A37400225D95 /* Code sense */; + executables = ( + F878A30309F3A36A00225D95 /* dees */, + ); + perUserDictionary = { + PBXConfiguration.PBXFileTableDataSource3.PBXExecutablesDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = "-1"; + PBXFileTableDataSourceColumnSortingKey = PBXExecutablesDataSource_NameID; + PBXFileTableDataSourceColumnWidthsKey = ( + 22, + 300, + 400, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXExecutablesDataSource_ActiveFlagID, + PBXExecutablesDataSource_NameID, + PBXExecutablesDataSource_CommentsID, + ); + }; + PBXConfiguration.PBXFileTableDataSource3.PBXFileTableDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = 1; + PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; + PBXFileTableDataSourceColumnWidthsKey = ( + 20, + 540, + 20, + 48, + 43, + 43, + 20, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXFileDataSource_FiletypeID, + PBXFileDataSource_Filename_ColumnID, + PBXFileDataSource_Built_ColumnID, + PBXFileDataSource_ObjectSize_ColumnID, + PBXFileDataSource_Errors_ColumnID, + PBXFileDataSource_Warnings_ColumnID, + PBXFileDataSource_Target_ColumnID, + ); + }; + PBXConfiguration.PBXFileTableDataSource3.PBXSymbolsDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = "-1"; + PBXFileTableDataSourceColumnSortingKey = PBXSymbolsDataSource_SymbolNameID; + PBXFileTableDataSourceColumnWidthsKey = ( + 16, + 200, + 50, + 200, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXSymbolsDataSource_SymbolTypeIconID, + PBXSymbolsDataSource_SymbolNameID, + PBXSymbolsDataSource_SymbolTypeID, + PBXSymbolsDataSource_ReferenceNameID, + ); + }; + PBXPerProjectTemplateStateSaveDate = 202045661; + PBXWorkspaceStateSaveDate = 202045661; + }; + perUserProjectItems = { + F80E92B009F4496F00850979 /* PBXTextBookmark */ = F80E92B009F4496F00850979 /* PBXTextBookmark */; + F80E92B109F4496F00850979 /* PBXTextBookmark */ = F80E92B109F4496F00850979 /* PBXTextBookmark */; + F80E92B309F4496F00850979 /* PBXTextBookmark */ = F80E92B309F4496F00850979 /* PBXTextBookmark */; + F84488190C0B4B5000D2870A /* PBXTextBookmark */ = F84488190C0B4B5000D2870A /* PBXTextBookmark */; + F844881A0C0B4B5000D2870A /* PBXTextBookmark */ = F844881A0C0B4B5000D2870A /* PBXTextBookmark */; + F844881B0C0B4B5000D2870A /* PBXTextBookmark */ = F844881B0C0B4B5000D2870A /* PBXTextBookmark */; + F860B02609F402D50027FF1E /* PBXTextBookmark */ = F860B02609F402D50027FF1E /* PBXTextBookmark */; + F860B02709F402D50027FF1E /* PBXTextBookmark */ = F860B02709F402D50027FF1E /* PBXTextBookmark */; + F860B03109F402D50027FF1E /* PBXTextBookmark */ = F860B03109F402D50027FF1E /* PBXTextBookmark */; + F860B03609F402D50027FF1E /* PBXTextBookmark */ = F860B03609F402D50027FF1E /* PBXTextBookmark */; + F860B03C09F402D50027FF1E /* PBXTextBookmark */ = F860B03C09F402D50027FF1E /* PBXTextBookmark */; + F860B0CA09F40B5F0027FF1E /* PBXTextBookmark */ = F860B0CA09F40B5F0027FF1E /* PBXTextBookmark */; + F860B0D109F40B5F0027FF1E /* PBXTextBookmark */ = F860B0D109F40B5F0027FF1E /* PBXTextBookmark */; + F860B0D309F40B5F0027FF1E /* PBXTextBookmark */ = F860B0D309F40B5F0027FF1E /* PBXTextBookmark */; + F860B0D409F40B5F0027FF1E /* PBXTextBookmark */ = F860B0D409F40B5F0027FF1E /* PBXTextBookmark */; + F860B0D509F40B5F0027FF1E /* PBXTextBookmark */ = F860B0D509F40B5F0027FF1E /* PBXTextBookmark */; + F860B0D609F40B5F0027FF1E /* PBXTextBookmark */ = F860B0D609F40B5F0027FF1E /* PBXTextBookmark */; + F860B0D809F40B5F0027FF1E /* PBXTextBookmark */ = F860B0D809F40B5F0027FF1E /* PBXTextBookmark */; + F871D10509F4E5D7001A8E9E /* PBXTextBookmark */ = F871D10509F4E5D7001A8E9E /* PBXTextBookmark */; + F871D17609F4F4A6001A8E9E /* PBXTextBookmark */ = F871D17609F4F4A6001A8E9E /* PBXTextBookmark */; + F871D17709F4F4A6001A8E9E /* PBXTextBookmark */ = F871D17709F4F4A6001A8E9E /* PBXTextBookmark */; + F871D17F09F4F4A6001A8E9E /* PBXTextBookmark */ = F871D17F09F4F4A6001A8E9E /* PBXTextBookmark */; + F876431509F7F5E500BAAC93 /* PBXTextBookmark */ = F876431509F7F5E500BAAC93 /* PBXTextBookmark */; + F896E5800BFB0BC400C659C6 /* PBXTextBookmark */ = F896E5800BFB0BC400C659C6 /* PBXTextBookmark */; + F896E5810BFB0BC400C659C6 /* PBXTextBookmark */ = F896E5810BFB0BC400C659C6 /* PBXTextBookmark */; + F896E5820BFB0BC400C659C6 /* PBXTextBookmark */ = F896E5820BFB0BC400C659C6 /* PBXTextBookmark */; + F896E5830BFB0BC400C659C6 /* PBXTextBookmark */ = F896E5830BFB0BC400C659C6 /* PBXTextBookmark */; + F896E5840BFB0BC400C659C6 /* PBXTextBookmark */ = F896E5840BFB0BC400C659C6 /* PBXTextBookmark */; + F896E5850BFB0BC400C659C6 /* PBXTextBookmark */ = F896E5850BFB0BC400C659C6 /* PBXTextBookmark */; + F896E5880BFB0BC400C659C6 /* PBXTextBookmark */ = F896E5880BFB0BC400C659C6 /* PBXTextBookmark */; + F8A1460C09F7E54200584BA4 /* PBXTextBookmark */ = F8A1460C09F7E54200584BA4 /* PBXTextBookmark */; + F8B74EFF09F9512000D55E52 /* PBXTextBookmark */ = F8B74EFF09F9512000D55E52 /* PBXTextBookmark */; + F8D16C060A2517DD00264622 /* PBXTextBookmark */ = F8D16C060A2517DD00264622 /* PBXTextBookmark */; + F8D93E540B8EE67900D2768C /* PBXTextBookmark */ = F8D93E540B8EE67900D2768C /* PBXTextBookmark */; + F8F48D780A243553009DE375 /* PBXTextBookmark */ = F8F48D780A243553009DE375 /* PBXTextBookmark */; + F8F48D790A243553009DE375 /* PBXTextBookmark */ = F8F48D790A243553009DE375 /* PBXTextBookmark */; + F8F48D7B0A243553009DE375 /* PBXTextBookmark */ = F8F48D7B0A243553009DE375 /* PBXTextBookmark */; + F8F48D7C0A243553009DE375 /* PBXTextBookmark */ = F8F48D7C0A243553009DE375 /* PBXTextBookmark */; + F8F48D7D0A243553009DE375 /* PBXTextBookmark */ = F8F48D7D0A243553009DE375 /* PBXTextBookmark */; + F8F48D7F0A243553009DE375 /* PBXTextBookmark */ = F8F48D7F0A243553009DE375 /* PBXTextBookmark */; + F8F48D800A243553009DE375 /* PBXTextBookmark */ = F8F48D800A243553009DE375 /* PBXTextBookmark */; + F8F48D810A243553009DE375 /* PBXTextBookmark */ = F8F48D810A243553009DE375 /* PBXTextBookmark */; + }; + sourceControlManager = F878A30909F3A37400225D95 /* Source Control */; + userBuildSettings = { + }; + }; + 08FB7796FE84155DC02AAC07 /* main.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1268, 18536}}"; + sepNavSelRange = "{39687, 1}"; + sepNavVisRect = "{{0, 18111}, {775, 417}}"; + sepNavWindowFrame = "{{38, 39}, {947, 681}}"; + }; + }; + 8DD76F620486A84900D96B5E /* dees */ = { + activeExec = 0; + executables = ( + F878A30309F3A36A00225D95 /* dees */, + ); + }; + C6859E8B029090EE04C91782 /* dees.1 */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {908, 1106}}"; + sepNavSelRange = "{0, 0}"; + sepNavVisRect = "{{0, 554}, {908, 552}}"; + sepNavWindowFrame = "{{15, 60}, {947, 681}}"; + }; + }; + F80E92B009F4496F00850979 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31309F3A48B00225D95 /* test.cpp */; + name = "test.cpp: 382"; + rLen = 0; + rLoc = 1105; + rType = 0; + vrLen = 978; + vrLoc = 0; + }; + F80E92B109F4496F00850979 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32309F3A4A100225D95 /* test.H */; + name = "test.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 256; + vrLoc = 0; + }; + F80E92B309F4496F00850979 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32909F3A4A100225D95 /* main.H */; + name = "main.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1246; + vrLoc = 0; + }; + F84488190C0B4B5000D2870A /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32A09F3A4A100225D95 /* ma.H */; + name = "ma.H: coherent"; + rLen = 0; + rLoc = 11662; + rType = 0; + vrLen = 1058; + vrLoc = 10967; + }; + F844881A0C0B4B5000D2870A /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32A09F3A4A100225D95 /* ma.H */; + name = "ma.H: coherent"; + rLen = 0; + rLoc = 11662; + rType = 0; + vrLen = 1058; + vrLoc = 10967; + }; + F844881B0C0B4B5000D2870A /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32409F3A4A100225D95 /* spfa.H */; + name = "spfa.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1434; + vrLoc = 0; + }; + F860AF3809F3D8430027FF1E /* simplex.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 2758}}"; + sepNavSelRange = "{506, 14}"; + sepNavVisRect = "{{0, 0}, {775, 417}}"; + sepNavWindowFrame = "{{38, 39}, {947, 681}}"; + }; + }; + F860B02609F402D50027FF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32509F3A4A100225D95 /* simplex.H */; + name = "simplex.H: add_absolute_constraint_with_parameters"; + rLen = 0; + rLoc = 1834; + rType = 0; + vrLen = 558; + vrLoc = 0; + }; + F860B02709F402D50027FF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F860AF3809F3D8430027FF1E /* simplex.cpp */; + name = "simplex.cpp: 12"; + rLen = 0; + rLoc = 5023; + rType = 0; + vrLen = 162; + vrLoc = 0; + }; + F860B03109F402D50027FF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 08FB7796FE84155DC02AAC07 /* main.cpp */; + name = "main.cpp: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 2141; + vrLoc = 0; + }; + F860B03609F402D50027FF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32709F3A4A100225D95 /* pprfa.H */; + name = "pprfa.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1849; + vrLoc = 1358; + }; + F860B03C09F402D50027FF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32609F3A4A100225D95 /* sample.H */; + name = "sample.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1370; + vrLoc = 0; + }; + F860B0CA09F40B5F0027FF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32C09F3A4A100225D95 /* general.H */; + name = "general.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1277; + vrLoc = 0; + }; + F860B0D109F40B5F0027FF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31709F3A48B00225D95 /* pprfa.cpp */; + name = "pprfa.cpp: 1478"; + rLen = 0; + rLoc = 4256; + rType = 0; + vrLen = 1161; + vrLoc = 702; + }; + F860B0D309F40B5F0027FF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32C09F3A4A100225D95 /* general.H */; + name = "general.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1277; + vrLoc = 0; + }; + F860B0D409F40B5F0027FF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31809F3A48B00225D95 /* pfa.cpp */; + name = T_M; + rLen = 3; + rLoc = 6126; + rType = 0; + vrLen = 788; + vrLoc = 5819; + }; + F860B0D509F40B5F0027FF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31909F3A48B00225D95 /* ma.cpp */; + name = "ma.cpp: 1602"; + rLen = 0; + rLoc = 45081; + rType = 0; + vrLen = 924; + vrLoc = 44822; + }; + F860B0D609F40B5F0027FF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32A09F3A4A100225D95 /* ma.H */; + name = "ma.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1530; + vrLoc = 0; + }; + F860B0D809F40B5F0027FF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32809F3A4A100225D95 /* pfa.H */; + name = "pfa.H: 32"; + rLen = 0; + rLoc = 1490; + rType = 0; + vrLen = 1250; + vrLoc = 1244; + }; + F871D10509F4E5D7001A8E9E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31409F3A48B00225D95 /* spfa.cpp */; + name = "spfa.cpp: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1567; + vrLoc = 0; + }; + F871D15409F4F14C001A8E9E /* pprfa_dees.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {812, 7504}}"; + sepNavSelRange = "{5026, 0}"; + sepNavVisRect = "{{0, 2187}, {775, 417}}"; + }; + }; + F871D16009F4F3D6001A8E9E /* pprfa_bm.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {800, 5922}}"; + sepNavSelRange = "{161, 0}"; + sepNavVisRect = "{{0, 199}, {775, 417}}"; + }; + }; + F871D17609F4F4A6001A8E9E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31609F3A48B00225D95 /* sample.cpp */; + name = "sample.cpp: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1511; + vrLoc = 0; + }; + F871D17709F4F4A6001A8E9E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F871D15409F4F14C001A8E9E /* pprfa_dees.cpp */; + name = "pprfa_dees.cpp: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 168; + vrLoc = 0; + }; + F871D17F09F4F4A6001A8E9E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F871D16009F4F3D6001A8E9E /* pprfa_bm.cpp */; + name = "pprfa_bm.cpp: 10"; + rLen = 0; + rLoc = 158; + rType = 0; + vrLen = 161; + vrLoc = 0; + }; + F876431509F7F5E500BAAC93 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32909F3A4A100225D95 /* main.H */; + name = "main.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1125; + vrLoc = 0; + }; + F878A30309F3A36A00225D95 /* dees */ = { + isa = PBXExecutable; + activeArgIndex = 0; + activeArgIndices = ( + YES, + ); + argumentStrings = ( + "--deesha test/sample", + ); + autoAttachOnCrash = 1; + configStateDict = { + "PBXLSLaunchAction-0" = { + PBXLSLaunchAction = 0; + PBXLSLaunchStartAction = 1; + PBXLSLaunchStdioStyle = 2; + PBXLSLaunchStyle = 0; + class = PBXLSRunLaunchConfig; + displayName = "Executable Runner"; + identifier = com.apple.Xcode.launch.runConfig; + remoteHostInfo = ""; + startActionInfo = ""; + }; + }; + customDataFormattersEnabled = 1; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + dylibVariantSuffix = ""; + enableDebugStr = 1; + environmentEntries = ( + ); + executableSystemSymbolLevel = 0; + executableUserSymbolLevel = 0; + libgmallocEnabled = 0; + name = dees; + savedGlobals = { + }; + sourceDirectories = ( + ); + startupPath = "<>"; + }; + F878A30909F3A37400225D95 /* Source Control */ = { + isa = PBXSourceControlManager; + fallbackIsa = XCSourceControlManager; + isSCMEnabled = 0; + scmConfiguration = { + }; + scmType = ""; + }; + F878A30A09F3A37400225D95 /* Code sense */ = { + isa = PBXCodeSenseManager; + indexTemplatePath = ""; + }; + F878A31309F3A48B00225D95 /* test.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 1302}}"; + sepNavSelRange = "{202, 339}"; + sepNavVisRect = "{{0, 199}, {775, 417}}"; + sepNavWindowFrame = "{{38, 39}, {947, 681}}"; + }; + }; + F878A31409F3A48B00225D95 /* spfa.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 17990}}"; + sepNavSelRange = "{13975, 1446}"; + sepNavVisRect = "{{0, 6177}, {775, 417}}"; + }; + }; + F878A31609F3A48B00225D95 /* sample.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 10682}}"; + sepNavSelRange = "{0, 0}"; + sepNavVisRect = "{{0, 199}, {775, 417}}"; + }; + }; + F878A31709F3A48B00225D95 /* pprfa.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 4760}}"; + sepNavSelRange = "{2882, 0}"; + sepNavVisRect = "{{0, 1330}, {775, 417}}"; + }; + }; + F878A31809F3A48B00225D95 /* pfa.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 9996}}"; + sepNavSelRange = "{8783, 0}"; + sepNavVisRect = "{{0, 4592}, {775, 417}}"; + }; + }; + F878A31909F3A48B00225D95 /* ma.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {908, 35882}}"; + sepNavSelRange = "{56358, 0}"; + sepNavVisRect = "{{0, 27211}, {775, 417}}"; + }; + }; + F878A31A09F3A48B00225D95 /* interface.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 9744}}"; + sepNavSelRange = "{13429, 0}"; + sepNavVisRect = "{{0, 7462}, {775, 417}}"; + }; + }; + F878A32309F3A4A100225D95 /* test.H */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 417}}"; + sepNavSelRange = "{0, 0}"; + sepNavVisRect = "{{0, 0}, {775, 417}}"; + sepNavWindowFrame = "{{15, 60}, {947, 681}}"; + }; + }; + F878A32409F3A4A100225D95 /* spfa.H */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {738, 2366}}"; + sepNavSelRange = "{0, 0}"; + sepNavVisRect = "{{0, 0}, {738, 391}}"; + }; + }; + F878A32509F3A4A100225D95 /* simplex.H */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 1092}}"; + sepNavSelRange = "{1213, 0}"; + sepNavVisRect = "{{0, 499}, {775, 417}}"; + sepNavWindowFrame = "{{61, 18}, {947, 681}}"; + }; + }; + F878A32609F3A4A100225D95 /* sample.H */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 2856}}"; + sepNavSelRange = "{0, 0}"; + sepNavVisRect = "{{0, 0}, {775, 417}}"; + }; + }; + F878A32709F3A4A100225D95 /* pprfa.H */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {854, 2520}}"; + sepNavSelRange = "{1574, 25}"; + sepNavVisRect = "{{0, 384}, {337, 199}}"; + sepNavWindowFrame = "{{15, 60}, {947, 681}}"; + }; + }; + F878A32809F3A4A100225D95 /* pfa.H */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 1582}}"; + sepNavSelRange = "{4161, 0}"; + sepNavVisRect = "{{0, 919}, {775, 417}}"; + sepNavWindowFrame = "{{15, 60}, {947, 681}}"; + }; + }; + F878A32909F3A4A100225D95 /* main.H */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 490}}"; + sepNavSelRange = "{0, 0}"; + sepNavVisRect = "{{0, 0}, {775, 417}}"; + }; + }; + F878A32A09F3A4A100225D95 /* ma.H */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {2390, 3906}}"; + sepNavSelRange = "{11662, 0}"; + sepNavVisRect = "{{0, 3515}, {738, 391}}"; + }; + }; + F878A32C09F3A4A100225D95 /* general.H */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {775, 1904}}"; + sepNavSelRange = "{0, 0}"; + sepNavVisRect = "{{0, 0}, {775, 417}}"; + }; + }; + F896E5800BFB0BC400C659C6 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F860AF3809F3D8430027FF1E /* simplex.cpp */; + name = realNotBounded; + rLen = 14; + rLoc = 506; + rType = 0; + vrLen = 735; + vrLoc = 0; + }; + F896E5810BFB0BC400C659C6 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32309F3A4A100225D95 /* test.H */; + name = "test.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 256; + vrLoc = 0; + }; + F896E5820BFB0BC400C659C6 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32509F3A4A100225D95 /* simplex.H */; + name = "simplex.H: 51"; + rLen = 0; + rLoc = 1213; + rType = 0; + vrLen = 831; + vrLoc = 833; + }; + F896E5830BFB0BC400C659C6 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32609F3A4A100225D95 /* sample.H */; + name = "sample.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1370; + vrLoc = 0; + }; + F896E5840BFB0BC400C659C6 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31309F3A48B00225D95 /* test.cpp */; + name = "test.cpp: test_PSe"; + rLen = 339; + rLoc = 202; + rType = 0; + vrLen = 553; + vrLoc = 224; + }; + F896E5850BFB0BC400C659C6 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32409F3A4A100225D95 /* spfa.H */; + name = "spfa.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1839; + vrLoc = 1668; + }; + F896E5880BFB0BC400C659C6 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32409F3A4A100225D95 /* spfa.H */; + name = "spfa.H: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 1450; + vrLoc = 0; + }; + F8A1460C09F7E54200584BA4 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31A09F3A48B00225D95 /* interface.cpp */; + name = "interface.cpp: Apprentissage_unique"; + rLen = 0; + rLoc = 13429; + rType = 0; + vrLen = 793; + vrLoc = 15362; + }; + F8B74EFF09F9512000D55E52 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32709F3A4A100225D95 /* pprfa.H */; + name = "pprfa.H: 58"; + rLen = 0; + rLoc = 2418; + rType = 0; + vrLen = 1427; + vrLoc = 1631; + }; + F8D16C060A2517DD00264622 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31909F3A48B00225D95 /* ma.cpp */; + name = "ma.cpp: 1968"; + rLen = 0; + rLoc = 56358; + rType = 0; + vrLen = 1109; + vrLoc = 55440; + }; + F8D93E540B8EE67900D2768C /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31409F3A48B00225D95 /* spfa.cpp */; + name = "spfa.cpp: 455"; + rLen = 1446; + rLoc = 13975; + rType = 0; + vrLen = 657; + vrLoc = 13736; + }; + F8F48D780A243553009DE375 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 08FB7796FE84155DC02AAC07 /* main.cpp */; + name = "}"; + rLen = 1; + rLoc = 39687; + rType = 0; + vrLen = 762; + vrLoc = 38926; + }; + F8F48D790A243553009DE375 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A32809F3A4A100225D95 /* pfa.H */; + name = "pfa.H: perplexite"; + rLen = 0; + rLoc = 4161; + rType = 0; + vrLen = 1560; + vrLoc = 3595; + }; + F8F48D7B0A243553009DE375 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F871D15409F4F14C001A8E9E /* pprfa_dees.cpp */; + name = "pprfa_dees.cpp: 176"; + rLen = 0; + rLoc = 5026; + rType = 0; + vrLen = 1001; + vrLoc = 4451; + }; + F8F48D7C0A243553009DE375 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F871D16009F4F3D6001A8E9E /* pprfa_bm.cpp */; + name = "pprfa_bm.cpp: becomeQuasiPrefixTree"; + rLen = 0; + rLoc = 161; + rType = 0; + vrLen = 561; + vrLoc = 289; + }; + F8F48D7D0A243553009DE375 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31A09F3A48B00225D95 /* interface.cpp */; + name = "interface.cpp: Apprentissage_unique"; + rLen = 0; + rLoc = 13429; + rType = 0; + vrLen = 534; + vrLoc = 15362; + }; + F8F48D7F0A243553009DE375 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31809F3A48B00225D95 /* pfa.cpp */; + name = "pfa.cpp: 332"; + rLen = 0; + rLoc = 8783; + rType = 0; + vrLen = 611; + vrLoc = 8734; + }; + F8F48D800A243553009DE375 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31709F3A48B00225D95 /* pprfa.cpp */; + name = "pprfa.cpp: 99"; + rLen = 0; + rLoc = 2882; + rType = 0; + vrLen = 627; + vrLoc = 2817; + }; + F8F48D810A243553009DE375 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = F878A31609F3A48B00225D95 /* sample.cpp */; + name = "sample.cpp: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 656; + vrLoc = 855; + }; +} diff --git a/dees.xcodeproj/project.pbxproj b/dees.xcodeproj/project.pbxproj new file mode 100644 index 0000000..4fca345 --- /dev/null +++ b/dees.xcodeproj/project.pbxproj @@ -0,0 +1,318 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 8DD76F650486A84900D96B5E /* main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 08FB7796FE84155DC02AAC07 /* main.cpp */; settings = {ATTRIBUTES = (); }; }; + 8DD76F6A0486A84900D96B5E /* dees.1 in CopyFiles */ = {isa = PBXBuildFile; fileRef = C6859E8B029090EE04C91782 /* dees.1 */; }; + F860AF3909F3D8430027FF1E /* simplex.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F860AF3809F3D8430027FF1E /* simplex.cpp */; }; + F871D15509F4F14C001A8E9E /* pprfa_dees.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F871D15409F4F14C001A8E9E /* pprfa_dees.cpp */; }; + F871D16109F4F3D6001A8E9E /* pprfa_bm.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F871D16009F4F3D6001A8E9E /* pprfa_bm.cpp */; }; + F878A31B09F3A48B00225D95 /* test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F878A31309F3A48B00225D95 /* test.cpp */; }; + F878A31C09F3A48B00225D95 /* spfa.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F878A31409F3A48B00225D95 /* spfa.cpp */; }; + F878A31E09F3A48B00225D95 /* sample.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F878A31609F3A48B00225D95 /* sample.cpp */; }; + F878A31F09F3A48B00225D95 /* pprfa.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F878A31709F3A48B00225D95 /* pprfa.cpp */; }; + F878A32009F3A48B00225D95 /* pfa.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F878A31809F3A48B00225D95 /* pfa.cpp */; }; + F878A32109F3A48B00225D95 /* ma.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F878A31909F3A48B00225D95 /* ma.cpp */; }; + F878A32209F3A48B00225D95 /* interface.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F878A31A09F3A48B00225D95 /* interface.cpp */; }; + F878A32D09F3A4A100225D95 /* test.H in CopyFiles */ = {isa = PBXBuildFile; fileRef = F878A32309F3A4A100225D95 /* test.H */; }; + F878A32E09F3A4A100225D95 /* spfa.H in CopyFiles */ = {isa = PBXBuildFile; fileRef = F878A32409F3A4A100225D95 /* spfa.H */; }; + F878A32F09F3A4A100225D95 /* simplex.H in CopyFiles */ = {isa = PBXBuildFile; fileRef = F878A32509F3A4A100225D95 /* simplex.H */; }; + F878A33009F3A4A100225D95 /* sample.H in CopyFiles */ = {isa = PBXBuildFile; fileRef = F878A32609F3A4A100225D95 /* sample.H */; }; + F878A33109F3A4A100225D95 /* pprfa.H in CopyFiles */ = {isa = PBXBuildFile; fileRef = F878A32709F3A4A100225D95 /* pprfa.H */; }; + F878A33209F3A4A100225D95 /* pfa.H in CopyFiles */ = {isa = PBXBuildFile; fileRef = F878A32809F3A4A100225D95 /* pfa.H */; }; + F878A33309F3A4A100225D95 /* main.H in CopyFiles */ = {isa = PBXBuildFile; fileRef = F878A32909F3A4A100225D95 /* main.H */; }; + F878A33409F3A4A100225D95 /* ma.H in CopyFiles */ = {isa = PBXBuildFile; fileRef = F878A32A09F3A4A100225D95 /* ma.H */; }; + F878A33509F3A4A100225D95 /* interface.H in CopyFiles */ = {isa = PBXBuildFile; fileRef = F878A32B09F3A4A100225D95 /* interface.H */; }; + F878A33609F3A4A100225D95 /* general.H in CopyFiles */ = {isa = PBXBuildFile; fileRef = F878A32C09F3A4A100225D95 /* general.H */; }; + F878A33809F3A4B700225D95 /* liblpsolve55.a in Frameworks */ = {isa = PBXBuildFile; fileRef = F878A33709F3A4B700225D95 /* liblpsolve55.a */; }; + F878A33A09F3A4D300225D95 /* lp_lib.h in CopyFiles */ = {isa = PBXBuildFile; fileRef = F878A33909F3A4D200225D95 /* lp_lib.h */; }; +/* End PBXBuildFile section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 8DD76F690486A84900D96B5E /* CopyFiles */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 8; + dstPath = /usr/share/man/man1/; + dstSubfolderSpec = 0; + files = ( + 8DD76F6A0486A84900D96B5E /* dees.1 in CopyFiles */, + F878A32D09F3A4A100225D95 /* test.H in CopyFiles */, + F878A32E09F3A4A100225D95 /* spfa.H in CopyFiles */, + F878A32F09F3A4A100225D95 /* simplex.H in CopyFiles */, + F878A33009F3A4A100225D95 /* sample.H in CopyFiles */, + F878A33109F3A4A100225D95 /* pprfa.H in CopyFiles */, + F878A33209F3A4A100225D95 /* pfa.H in CopyFiles */, + F878A33309F3A4A100225D95 /* main.H in CopyFiles */, + F878A33409F3A4A100225D95 /* ma.H in CopyFiles */, + F878A33509F3A4A100225D95 /* interface.H in CopyFiles */, + F878A33609F3A4A100225D95 /* general.H in CopyFiles */, + F878A33A09F3A4D300225D95 /* lp_lib.h in CopyFiles */, + ); + runOnlyForDeploymentPostprocessing = 1; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 08FB7796FE84155DC02AAC07 /* main.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = main.cpp; sourceTree = ""; }; + 8DD76F6C0486A84900D96B5E /* dees */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = dees; sourceTree = BUILT_PRODUCTS_DIR; }; + C6859E8B029090EE04C91782 /* dees.1 */ = {isa = PBXFileReference; lastKnownFileType = text.man; path = dees.1; sourceTree = ""; }; + F860AF3809F3D8430027FF1E /* simplex.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = simplex.cpp; sourceTree = ""; }; + F871D15409F4F14C001A8E9E /* pprfa_dees.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pprfa_dees.cpp; sourceTree = ""; }; + F871D16009F4F3D6001A8E9E /* pprfa_bm.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pprfa_bm.cpp; sourceTree = ""; }; + F878A31309F3A48B00225D95 /* test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = test.cpp; sourceTree = ""; }; + F878A31409F3A48B00225D95 /* spfa.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = spfa.cpp; sourceTree = ""; }; + F878A31609F3A48B00225D95 /* sample.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sample.cpp; sourceTree = ""; }; + F878A31709F3A48B00225D95 /* pprfa.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pprfa.cpp; sourceTree = ""; }; + F878A31809F3A48B00225D95 /* pfa.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pfa.cpp; sourceTree = ""; }; + F878A31909F3A48B00225D95 /* ma.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ma.cpp; sourceTree = ""; }; + F878A31A09F3A48B00225D95 /* interface.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = interface.cpp; sourceTree = ""; }; + F878A32309F3A4A100225D95 /* test.H */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = test.H; sourceTree = ""; }; + F878A32409F3A4A100225D95 /* spfa.H */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = spfa.H; sourceTree = ""; }; + F878A32509F3A4A100225D95 /* simplex.H */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = simplex.H; sourceTree = ""; }; + F878A32609F3A4A100225D95 /* sample.H */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = sample.H; sourceTree = ""; }; + F878A32709F3A4A100225D95 /* pprfa.H */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = pprfa.H; sourceTree = ""; }; + F878A32809F3A4A100225D95 /* pfa.H */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = pfa.H; sourceTree = ""; }; + F878A32909F3A4A100225D95 /* main.H */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = main.H; sourceTree = ""; }; + F878A32A09F3A4A100225D95 /* ma.H */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = ma.H; sourceTree = ""; }; + F878A32B09F3A4A100225D95 /* interface.H */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = interface.H; sourceTree = ""; }; + F878A32C09F3A4A100225D95 /* general.H */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = general.H; sourceTree = ""; }; + F878A33709F3A4B700225D95 /* liblpsolve55.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = liblpsolve55.a; path = lib/liblpsolve55.a; sourceTree = ""; }; + F878A33909F3A4D200225D95 /* lp_lib.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = lp_lib.h; path = include/lp_lib.h; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 8DD76F660486A84900D96B5E /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + F878A33809F3A4B700225D95 /* liblpsolve55.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* dees */ = { + isa = PBXGroup; + children = ( + F878A31209F3A46500225D95 /* include */, + F878A31109F3A45600225D95 /* lib */, + F878A31009F3A44A00225D95 /* Headers */, + 08FB7795FE84155DC02AAC07 /* Source */, + C6859E8C029090F304C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = dees; + sourceTree = ""; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + F878A31309F3A48B00225D95 /* test.cpp */, + F878A31409F3A48B00225D95 /* spfa.cpp */, + F878A31609F3A48B00225D95 /* sample.cpp */, + F878A31709F3A48B00225D95 /* pprfa.cpp */, + F878A31809F3A48B00225D95 /* pfa.cpp */, + F878A31909F3A48B00225D95 /* ma.cpp */, + F878A31A09F3A48B00225D95 /* interface.cpp */, + 08FB7796FE84155DC02AAC07 /* main.cpp */, + F860AF3809F3D8430027FF1E /* simplex.cpp */, + F871D15409F4F14C001A8E9E /* pprfa_dees.cpp */, + F871D16009F4F3D6001A8E9E /* pprfa_bm.cpp */, + ); + name = Source; + sourceTree = ""; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + 8DD76F6C0486A84900D96B5E /* dees */, + ); + name = Products; + sourceTree = ""; + }; + C6859E8C029090F304C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + C6859E8B029090EE04C91782 /* dees.1 */, + ); + name = Documentation; + sourceTree = ""; + }; + F878A31009F3A44A00225D95 /* Headers */ = { + isa = PBXGroup; + children = ( + F878A32309F3A4A100225D95 /* test.H */, + F878A32409F3A4A100225D95 /* spfa.H */, + F878A32509F3A4A100225D95 /* simplex.H */, + F878A32609F3A4A100225D95 /* sample.H */, + F878A32709F3A4A100225D95 /* pprfa.H */, + F878A32809F3A4A100225D95 /* pfa.H */, + F878A32909F3A4A100225D95 /* main.H */, + F878A32A09F3A4A100225D95 /* ma.H */, + F878A32B09F3A4A100225D95 /* interface.H */, + F878A32C09F3A4A100225D95 /* general.H */, + ); + name = Headers; + sourceTree = ""; + }; + F878A31109F3A45600225D95 /* lib */ = { + isa = PBXGroup; + children = ( + F878A33709F3A4B700225D95 /* liblpsolve55.a */, + ); + name = lib; + sourceTree = ""; + }; + F878A31209F3A46500225D95 /* include */ = { + isa = PBXGroup; + children = ( + F878A33909F3A4D200225D95 /* lp_lib.h */, + ); + name = include; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 8DD76F620486A84900D96B5E /* dees */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB923108733DC60010E9CD /* Build configuration list for PBXNativeTarget "dees" */; + buildPhases = ( + 8DD76F640486A84900D96B5E /* Sources */, + 8DD76F660486A84900D96B5E /* Frameworks */, + 8DD76F690486A84900D96B5E /* CopyFiles */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = dees; + productInstallPath = "$(HOME)/bin"; + productName = dees; + productReference = 8DD76F6C0486A84900D96B5E /* dees */; + productType = "com.apple.product-type.tool"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB923508733DC60010E9CD /* Build configuration list for PBXProject "dees" */; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* dees */; + projectDirPath = ""; + targets = ( + 8DD76F620486A84900D96B5E /* dees */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + 8DD76F640486A84900D96B5E /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 8DD76F650486A84900D96B5E /* main.cpp in Sources */, + F878A31B09F3A48B00225D95 /* test.cpp in Sources */, + F878A31C09F3A48B00225D95 /* spfa.cpp in Sources */, + F878A31E09F3A48B00225D95 /* sample.cpp in Sources */, + F878A31F09F3A48B00225D95 /* pprfa.cpp in Sources */, + F878A32009F3A48B00225D95 /* pfa.cpp in Sources */, + F878A32109F3A48B00225D95 /* ma.cpp in Sources */, + F878A32209F3A48B00225D95 /* interface.cpp in Sources */, + F860AF3909F3D8430027FF1E /* simplex.cpp in Sources */, + F871D15509F4F14C001A8E9E /* pprfa_dees.cpp in Sources */, + F871D16109F4F3D6001A8E9E /* pprfa_bm.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB923208733DC60010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = "$(HOME)/bin"; + LIBRARY_SEARCH_PATHS = ( + "$(LIBRARY_SEARCH_PATHS)", + "$(SRCROOT)/lib", + ); + PRODUCT_NAME = dees; + ZERO_LINK = YES; + }; + name = Debug; + }; + 1DEB923308733DC60010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + INSTALL_PATH = "$(HOME)/bin"; + LIBRARY_SEARCH_PATHS = ( + "$(LIBRARY_SEARCH_PATHS)", + "$(SRCROOT)/lib", + ); + PRODUCT_NAME = dees; + }; + name = Release; + }; + 1DEB923608733DC60010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + }; + name = Debug; + }; + 1DEB923708733DC60010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB923108733DC60010E9CD /* Build configuration list for PBXNativeTarget "dees" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB923208733DC60010E9CD /* Debug */, + 1DEB923308733DC60010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB923508733DC60010E9CD /* Build configuration list for PBXProject "dees" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB923608733DC60010E9CD /* Debug */, + 1DEB923708733DC60010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/general.H b/general.H new file mode 100644 index 0000000..c5c308d --- /dev/null +++ b/general.H @@ -0,0 +1,135 @@ +/*************************************************************************** + general.h - This file must be included in all Project + ------------------- + begin : Thu Jul 18 2002 + copyright : (C) 2002 by Yann Esposito + email : esposito@cmi.univ-mrs.fr +***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +#ifndef GENERAL_H +#define GENERAL_H + +using namespace std; +#include +#include +#include +//#include +//#include +#include // pour cout << +#include // pour fic << +#include + +// ------------- pour le portage -------------- + +// pour compiler sur le ppc + +#ifdef __ppc__ +#define isnan __isnan +#define isinf __isinf +#endif + +// pour utiliser les hash_map +#ifdef __GNUC__ + #if __GNUC__ < 3 + #include + +namespace hmext +{ +using ::hash_map; +} +; // inherit globals +#else + #include + #if __GNUC_MINOR__ == 0 + +namespace hmext = std; // GCC 3.0 +#else + +namespace hmext = ::__gnu_cxx; // GCC 3.1 and later +#endif + #endif + #else // ... there are other compilers, right? + +namespace hmext = std; +#endif + +// ------------------------------------------------ + +// Make DEBUG false to disable the debug mode (faster but you'll lose all error messages). +const bool PFA_DEBUG = true; + +// Make VERBOSE false to disable the verbose mode (less messages) +const bool PFA_VERBOSE = true; + +// Make SAFE false to disable the SAFE mode (faster but DANGEROUS !!!!) +const bool PFA_SAFE = true; + +// Definition of the RESULT type. +typedef int RESULT; + +// Test if the result of a function is OK. +inline RESULT +OK (RESULT x) +{ + return x >= 0; +} +inline RESULT +VAL (RESULT x) +{ + return x; +} +inline RESULT +ERR (RESULT x) +{ + if (x >= 0) + return -1 - x; + else + return -1 + x; +} + +// =============== Définition des types necessaires aux structures de données ============== +// ___ Située hors des classes pour éviter l'utilisation de l'opérateur de résolution ___ + +typedef int State; // Le type état +typedef char Lettre; // Le type lettre +typedef basic_string< Lettre > Word; // Le type Word +//~ class Word : public basic_string < Lettre > // Le type mot +//~ { +//~ public: +//~ inline Lettre pop_back() { +//~ iterator e=end(); +//~ --e; +//~ Lettre a=*e; +//~ erase(e); +//~ return a; +//~ } +//~ }; + +typedef set< Lettre > Alphabet; // type Alphabet +typedef string TrueLettre; // real letters. +//typedef hash_map < Lettre, TrueLettre > Dictionnaire; // type Dictionnaire +typedef map < Lettre, TrueLettre > Dictionnaire; // type Dictionnaire (association lettre et vraie lettre) + +//typedef hmext::hash_map < State, double >PreciseSFunc; // Type fonction State --> IR, plus précise +typedef map < State, double >PreciseSFunc; // Type fonction State --> IR, plus précise + +// Le type transition n'est pas forcement necessaire mais il est joli +// Type transition est un triplet State x Lettre x State +typedef struct str_Transition +{ + State qdep; + Lettre a; + State qarr; +} +Transition; + +#endif diff --git a/help/help.txt b/help/help.txt new file mode 100644 index 0000000..ca4576e --- /dev/null +++ b/help/help.txt @@ -0,0 +1,39 @@ +Usage : +dees OPTIONS + +OPTIONS : +-H affiche l'aide étendue (options) +-Y ou -I envoie la fonction Y (mode interactif) + + +--- APPRENTISSAGE --- +--dees algorithme DEES +--dees2 algorithme DEES2 +--deesbm algorithme DEES avec Baum Welch +--alergia algorithme alergia +--mdi algorithme mdi +--bm algorithme Baum Welch + +--learn apprend avec validation croisée +--learnbm apprentissage avec ensemble test avec methode deesBM +--learnmdi apprentissage avec MDI +--learnalergia apprentissage avec alergia +--bestlearn plusieurs apprentissages pour trouver le meilleur + +--- MANIPULATION DE FICHIERS --- +--export exporte vers des formats d'automates differents +--convert convertit des echantillons + +--- OUTILS DE DIAGNOSTICS --- +--dist affiche la distance entre deux MA +--class affiche la classe d'un PFA +--affiche affiche un automate sur la sortie standard +--test fait un test à partir de l'automate +--proba show probabilities of words of a sample +-P or --showps affichage postscript + +--- MANIPULATION DE MA --- +--deletetransitions delete transitions of some value +--sample genere un échantillon +--grp genere un automate probabiliste +--random generate a random automaton diff --git a/include/declare.h b/include/declare.h new file mode 100644 index 0000000..fba1794 --- /dev/null +++ b/include/declare.h @@ -0,0 +1,22 @@ +#ifndef __DECLARE_H__ +#define __DECLARE_H__ + +#if !defined ANSI_PROTOTYPES +# if defined MSDOS || defined __BORLANDC__ || defined __HIGHC__ || defined SCO_UNIX || defined AViiON +# define ANSI_PROTOTYPES 1 +# endif +#endif + +#if ANSI_PROTOTYPES!=0 +# define __OF(args) args +#else +# define __OF(args) () +#endif + +#if defined __HIGHC__ +# define VARARG ... +#else +# define VARARG +#endif + +#endif diff --git a/include/fortify.h b/include/fortify.h new file mode 100644 index 0000000..dd9b2db --- /dev/null +++ b/include/fortify.h @@ -0,0 +1,183 @@ +#ifndef __FORTIFY_H__ +#define __FORTIFY_H__ +/* + * FILE: + * fortify.h + * + * DESCRIPTION: + * Header file for fortify.c - A fortified shell for malloc, realloc, + * calloc, strdup, getcwd, tempnam & free + * + * WRITTEN: + * spb 29/4/94 + * + * VERSION: + * 1.0 29/4/94 + */ +#include + +#include "declare.h" + +#if defined HP9000 || defined AViiON || defined ALPHA || defined SIGNED_UNKNOWN +# define signed +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef FORTIFY + +typedef void (*OutputFuncPtr) __OF((char *)); + +extern char *_Fortify_file; +extern int _Fortify_line; + +#define Fortify_FILE(file) _Fortify_file=file +#define Fortify_LINE(line) _Fortify_line=line + +#define _Fortify_FILE (_Fortify_file==(char *) 0 ? __FILE__ : _Fortify_file) +#define _Fortify_LINE (_Fortify_line==0 ? __LINE__ : _Fortify_line) + +void _Fortify_Init __OF((char *file, unsigned long line)); +void *_Fortify_malloc __OF((size_t size, char *file, unsigned long line)); +void *_Fortify_realloc __OF((void *ptr, size_t new_size, char *file, unsigned long line)); +void *_Fortify_calloc __OF((size_t nitems, size_t size, char *file, unsigned long line)); +char *_Fortify_strdup __OF((char *str, char *file, unsigned long line)); +void *_Fortify_memcpy __OF((void *to, void *from, size_t size, char *file, unsigned long line)); +void *_Fortify_memmove __OF((void *to, void *from, size_t size, char *file, unsigned long line)); +void *_Fortify_memset __OF((void *buffer, int c, size_t size, char *file, unsigned long line)); +void *_Fortify_memchr __OF((void *buffer, int c, size_t size, char *file, unsigned long line)); +int _Fortify_memcmp __OF((void *buffer1, void *buffer2, size_t size, char *file, unsigned long line)); +char *_Fortify_strchr __OF((char *buffer, int c, char *file, unsigned long line)); +char *_Fortify_strset __OF((char *buffer, int c, char *file, unsigned long line)); +char *_Fortify_strcpy __OF((char *to, char *from, char *file, unsigned long line)); +char *_Fortify_strncpy __OF((char *to, char *from, size_t size, char *file, unsigned long line)); +int _Fortify_strncmp __OF((char *buffer1, char *buffer2, size_t size, char *file, unsigned long line)); +char *_Fortify_strcat __OF((char *buffer1, char *buffer2, char *file, unsigned long line)); +size_t _Fortify_strlen __OF((char *buffer, char *file, unsigned long line)); +char *_Fortify_getcwd __OF((char *buf, int size, char *file, unsigned long line)); +char *_Fortify_tempnam __OF((char *dir, char *pfx, char *file, unsigned long line)); +void _Fortify_free __OF((void *uptr, char *file, unsigned long line)); + +int _Fortify_OutputAllMemory __OF((char *file, unsigned long line)); +int _Fortify_CheckAllMemory __OF((char *file, unsigned long line)); +int _Fortify_CheckPointer __OF((void *uptr, char *file, unsigned long line)); +int _Fortify_Disable __OF((char *file, unsigned long line, int how)); +int _Fortify_SetMallocFailRate __OF((int Percent)); +int _Fortify_EnterScope __OF((char *file, unsigned long line)); +int _Fortify_LeaveScope __OF((char *file, unsigned long line)); +int _Fortify_DumpAllMemory __OF((int scope, char *file, unsigned long line)); + +typedef void (*Fortify_OutputFuncPtr) __OF((/* const */ char *)); +Fortify_OutputFuncPtr _Fortify_SetOutputFunc __OF((Fortify_OutputFuncPtr Output)); + +#endif /* FORTIFY */ + +#ifdef __cplusplus +} +#endif + +#ifndef __FORTIFY_C__ /* Only define the macros if we're NOT in fortify.c */ + +#ifdef FORTIFY /* Add file and line information to the fortify calls */ + +#if defined malloc +# undef malloc +#endif +#if defined realloc +# undef realloc +#endif +#if defined calloc +# undef calloc +#endif +#if defined strdup +# undef strdup +#endif +#if defined memcpy +# undef memcpy +#endif +#if defined memmove +# undef memmove +#endif +#if defined memset +# undef memset +#endif +#if defined memchr +# undef memchr +#endif +#if defined memcmp +# undef memcmp +#endif +#if defined strncmp +# undef strncmp +#endif +#if defined strchr +# undef strchr +#endif +#if defined strcat +# undef strcat +#endif +#if defined strset +# undef strset +#endif +#if defined strlen +# undef strlen +#endif +#if defined getcwd +# undef getcwd +#endif +#if defined tempnam +# undef tempnam +#endif +#if defined free +# undef free +#endif + +#define malloc(size) _Fortify_malloc(size, _Fortify_FILE, _Fortify_LINE) +#define realloc(ptr,new_size) _Fortify_realloc(ptr, new_size, _Fortify_FILE, _Fortify_LINE) +#define calloc(num,size) _Fortify_calloc(num, size, _Fortify_FILE, _Fortify_LINE) +#define strdup(str) _Fortify_strdup(str, _Fortify_FILE, _Fortify_LINE) +#define memcpy(to,from,size) _Fortify_memcpy(to,from,size, _Fortify_FILE, _Fortify_LINE) +#define memmove(to,from,size) _Fortify_memmove(to,from,size, _Fortify_FILE, _Fortify_LINE) +#define memset(buffer,c,size) _Fortify_memset(buffer,c,size, _Fortify_FILE, _Fortify_LINE) +#define memchr(buffer,c,size) _Fortify_memchr(buffer,c,size, _Fortify_FILE, _Fortify_LINE) +#define memcmp(buffer1,buffer2,size) _Fortify_memcmp(buffer1,buffer2,size, _Fortify_FILE, _Fortify_LINE) +#define strchr(buffer,c) _Fortify_strchr(buffer,c, _Fortify_FILE, _Fortify_LINE) +#define strset(buffer,c) _Fortify_strset(buffer,c, _Fortify_FILE, _Fortify_LINE) +#define strcpy(to,from) _Fortify_strcpy(to,from, _Fortify_FILE, _Fortify_LINE) +#define strncpy(to,from,size) _Fortify_strncpy(to,from,size, _Fortify_FILE, _Fortify_LINE) +#define strncmp(buffer1,buffer2,size) _Fortify_strncmp(buffer1,buffer2,size, _Fortify_FILE, _Fortify_LINE) +#define strcat(buffer1,buffer2) _Fortify_strcat(buffer1,buffer2, _Fortify_FILE, _Fortify_LINE) +#define strlen(buffer) _Fortify_strlen(buffer, _Fortify_FILE, _Fortify_LINE) +#define getcwd(buf,size) _Fortify_getcwd(buf, size, _Fortify_FILE, _Fortify_LINE) +#define tempnam(dir,pfx) _Fortify_tempnam(dir, pfx, _Fortify_FILE, _Fortify_LINE) +#define free(ptr) _Fortify_free(ptr, _Fortify_FILE, _Fortify_LINE) + +#define Fortify_Init() _Fortify_Init(_Fortify_FILE, _Fortify_LINE) +#define Fortify_OutputAllMemory() _Fortify_OutputAllMemory(_Fortify_FILE, _Fortify_LINE) +#define Fortify_CheckAllMemory() _Fortify_CheckAllMemory(_Fortify_FILE, _Fortify_LINE) +#define Fortify_CheckPointer(ptr) _Fortify_CheckPointer(ptr, _Fortify_FILE, _Fortify_LINE) +#define Fortify_Disable(how) _Fortify_Disable(_Fortify_FILE, _Fortify_LINE,how) +#define Fortify_EnterScope() _Fortify_EnterScope(_Fortify_FILE, _Fortify_LINE) +#define Fortify_LeaveScope() _Fortify_LeaveScope(_Fortify_FILE, _Fortify_LINE) +#define Fortify_DumpAllMemory(s) _Fortify_DumpAllMemory(s,_Fortify_FILE, _Fortify_LINE) + +#else /* FORTIFY Define the special fortify functions away to nothing */ + +#define Fortify_FILE(file) +#define Fortify_LINE(line) +#define Fortify_Init() +#define Fortify_OutputAllMemory() 0 +#define Fortify_CheckAllMemory() 0 +#define Fortify_CheckPointer(ptr) 1 +#define Fortify_Disable(how) 1 +#define Fortify_SetOutputFunc() 0 +#define Fortify_SetMallocFailRate(p) 0 +#define Fortify_EnterScope() 0 +#define Fortify_LeaveScope() 0 +#define Fortify_DumpAllMemory(s) 0 + +#endif /* FORTIFY */ +#endif /* __FORTIFY_C__ */ +#endif /* __FORTIFY_H__ */ diff --git a/include/ini.h b/include/ini.h new file mode 100644 index 0000000..bab76b5 --- /dev/null +++ b/include/ini.h @@ -0,0 +1,9 @@ +#include + +extern FILE *ini_create(char *filename); +extern FILE *ini_open(char *filename); +extern void ini_writecomment(FILE *fp, char *comment); +extern void ini_writeheader(FILE *fp, char *header, int addnewline); +extern void ini_writedata(FILE *fp, char *name, char *data); +extern int ini_readdata(FILE *fp, char *data, int szdata, int withcomment); +extern void ini_close(FILE *fp); diff --git a/include/lp_Hash.h b/include/lp_Hash.h new file mode 100644 index 0000000..d93a741 --- /dev/null +++ b/include/lp_Hash.h @@ -0,0 +1,43 @@ +#ifndef HEADER_lp_hash +#define HEADER_lp_hash + +/* For row and column name hash tables */ + +typedef struct _hashelem +{ + char *name; + int index; + struct _hashelem *next; + struct _hashelem *nextelem; +} hashelem; + +typedef struct _hashtable +{ + hashelem **table; + int size; + int base; + int count; + struct _hashelem *first; + struct _hashelem *last; +} hashtable; + +#ifdef __cplusplus +extern "C" { +#endif + +STATIC hashtable *create_hash_table(int size, int base); +STATIC void free_hash_table(hashtable *ht); +STATIC hashelem *findhash(const char *name, hashtable *ht); +STATIC hashelem *puthash(const char *name, int index, hashelem **list, hashtable *ht); +STATIC void drophash(const char *name, hashelem **list, hashtable *ht); +STATIC void free_hash_item(hashelem **hp); +STATIC hashtable *copy_hash_table(hashtable *ht, hashelem **list, int newsize); +STATIC int find_var(lprec *lp, char *name, MYBOOL verbose); +STATIC int find_row(lprec *lp, char *name, MYBOOL Unconstrained_rows_found); + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_lp_hash */ + diff --git a/include/lp_MDO.h b/include/lp_MDO.h new file mode 100644 index 0000000..8475363 --- /dev/null +++ b/include/lp_MDO.h @@ -0,0 +1,18 @@ +#ifndef HEADER_MDO +#define HEADER_MDO + +#include "lp_types.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +int __WINAPI getMDO(lprec *lp, MYBOOL *usedpos, int *colorder, int *size, MYBOOL symmetric); + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_MDO */ + diff --git a/include/lp_MPS.h b/include/lp_MPS.h new file mode 100644 index 0000000..218ed92 --- /dev/null +++ b/include/lp_MPS.h @@ -0,0 +1,37 @@ +#ifndef HEADER_lp_MPS +#define HEADER_lp_MPS + +#include "lp_types.h" + +/* For MPS file reading and writing */ +#define ROWNAMEMASK "R%d" +#define ROWNAMEMASK2 "r%d" +#define COLNAMEMASK "C%d" +#define COLNAMEMASK2 "c%d" + +#define MPSFIXED 1 +#define MPSFREE 2 + + +#ifdef __cplusplus +extern "C" { +#endif + +/* Read an MPS file */ +MYBOOL MPS_readfile(lprec **newlp, char *filename, int typeMPS, int verbose); +MYBOOL __WINAPI MPS_readhandle(lprec **newlp, FILE *filehandle, int typeMPS, int verbose); + +/* Write a MPS file to output */ +MYBOOL MPS_writefile(lprec *lp, int typeMPS, char *filename); +MYBOOL MPS_writehandle(lprec *lp, int typeMPS, FILE *output); + +/* Read and write BAS files */ +MYBOOL MPS_readBAS(lprec *lp, int typeMPS, char *filename, char *info); +MYBOOL MPS_writeBAS(lprec *lp, int typeMPS, char *filename); + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_lp_MPS */ + diff --git a/include/lp_SOS.h b/include/lp_SOS.h new file mode 100644 index 0000000..27df12c --- /dev/null +++ b/include/lp_SOS.h @@ -0,0 +1,108 @@ +#ifndef HEADER_lp_SOS +#define HEADER_lp_SOS + +/* Specially Ordered Sets (SOS) prototypes and settings */ +/* ------------------------------------------------------------------------- */ + +#include "lp_types.h" +#include "lp_utils.h" +#include "lp_matrix.h" + + +/* SOS constraint defines */ +/* ------------------------------------------------------------------------- */ +#define SOS1 1 +#define SOS2 2 +#define SOS3 -1 +#define SOSn MAXINT32 +#define SOS_START_SIZE 10 /* Start size of SOS_list array; realloced if needed */ + +/* Define SOS_is_feasible() return values */ +/* ------------------------------------------------------------------------- */ +#define SOS3_INCOMPLETE -2 +#define SOS_INCOMPLETE -1 +#define SOS_COMPLETE 0 +#define SOS_INFEASIBLE 1 +#define SOS_INTERNALERROR 2 + + +typedef struct _SOSgroup SOSgroup; + +typedef struct _SOSrec +{ + SOSgroup *parent; + int tagorder; + char *name; + int type; + MYBOOL isGUB; + int size; + int priority; + int *members; + REAL *weights; + int *membersSorted; + int *membersMapped; +} SOSrec; + +/* typedef */ struct _SOSgroup +{ + lprec *lp; /* Pointer to owner */ + SOSrec **sos_list; /* Array of pointers to SOS lists */ + int sos_alloc; /* Size allocated to specially ordered sets (SOS1, SOS2...) */ + int sos_count; /* Number of specially ordered sets (SOS1, SOS2...) */ + int maxorder; /* The highest-order SOS in the group */ + int sos1_count; /* Number of the lowest order SOS in the group */ + int *membership; /* Array of variable-sorted indeces to SOSes that the variable is member of */ + int *memberpos; /* Starting positions of the each column's membership list */ +} /* SOSgroup */; + + +#ifdef __cplusplus +extern "C" { +#endif + +/* SOS storage structure */ +STATIC SOSgroup *create_SOSgroup(lprec *lp); +STATIC void resize_SOSgroup(SOSgroup *group); +STATIC int append_SOSgroup(SOSgroup *group, SOSrec *SOS); +STATIC int clean_SOSgroup(SOSgroup *group, MYBOOL forceupdatemap); +STATIC void free_SOSgroup(SOSgroup **group); + +STATIC SOSrec *create_SOSrec(SOSgroup *group, char *name, int type, int priority, int size, int *variables, REAL *weights); +STATIC MYBOOL delete_SOSrec(SOSgroup *group, int sosindex); +STATIC int append_SOSrec(SOSrec *SOS, int size, int *variables, REAL *weights); +STATIC void free_SOSrec(SOSrec *SOS); + +/* SOS utilities */ +STATIC int make_SOSchain(lprec *lp, MYBOOL forceresort); +STATIC int SOS_member_updatemap(SOSgroup *group); +STATIC MYBOOL SOS_member_sortlist(SOSgroup *group, int sosindex); +STATIC MYBOOL SOS_shift_col(SOSgroup *group, int sosindex, int column, int delta, LLrec *usedmap, MYBOOL forceresort); +int SOS_member_delete(SOSgroup *group, int sosindex, int member); +int SOS_get_type(SOSgroup *group, int sosindex); +int SOS_infeasible(SOSgroup *group, int sosindex); +int SOS_member_index(SOSgroup *group, int sosindex, int member); +int SOS_member_count(SOSgroup *group, int sosindex); +int SOS_memberships(SOSgroup *group, int column); +int *SOS_get_candidates(SOSgroup *group, int sosindex, int column, MYBOOL excludetarget, REAL *upbound, REAL *lobound); +int SOS_is_member(SOSgroup *group, int sosindex, int column); +MYBOOL SOS_is_member_of_type(SOSgroup *group, int column, int sostype); +MYBOOL SOS_set_GUB(SOSgroup *group, int sosindex, MYBOOL state); +MYBOOL SOS_is_GUB(SOSgroup *group, int sosindex); +MYBOOL SOS_is_marked(SOSgroup *group, int sosindex, int column); +MYBOOL SOS_is_active(SOSgroup *group, int sosindex, int column); +MYBOOL SOS_is_full(SOSgroup *group, int sosindex, int column, MYBOOL activeonly); +MYBOOL SOS_can_activate(SOSgroup *group, int sosindex, int column); +MYBOOL SOS_set_marked(SOSgroup *group, int sosindex, int column, MYBOOL asactive); +MYBOOL SOS_unmark(SOSgroup *group, int sosindex, int column); +int SOS_fix_unmarked(SOSgroup *group, int sosindex, int variable, REAL *bound, REAL value, + MYBOOL isupper, int *diffcount, DeltaVrec *changelog); +int SOS_fix_list(SOSgroup *group, int sosindex, int variable, REAL *bound, + int *varlist, MYBOOL isleft, DeltaVrec *changelog); +int SOS_is_satisfied(SOSgroup *group, int sosindex, REAL *solution); +MYBOOL SOS_is_feasible(SOSgroup *group, int sosindex, REAL *solution); + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_lp_SOS */ diff --git a/include/lp_crash.h b/include/lp_crash.h new file mode 100644 index 0000000..9eb1760 --- /dev/null +++ b/include/lp_crash.h @@ -0,0 +1,29 @@ + +#ifndef HEADER_lp_crash +#define HEADER_lp_crash + + +#include "lp_types.h" + +#define CRASH_SIMPLESCALE /* Specify if we should use a simple absolute scaling threshold */ + +#define CRASH_THRESHOLD 0.167 +#define CRASH_SPACER 10 +#define CRASH_WEIGHT 0.500 + + + +#ifdef __cplusplus +__EXTERN_C { +#endif + +STATIC MYBOOL crash_basis(lprec *lp); +STATIC MYBOOL guess_basis(lprec *lp, REAL *guessvector, int *basisvector); + + +#ifdef __cplusplus +} +#endif + +#endif /* HEADER_lp_crash */ + diff --git a/include/lp_explicit.h b/include/lp_explicit.h new file mode 100644 index 0000000..e004b75 --- /dev/null +++ b/include/lp_explicit.h @@ -0,0 +1,1016 @@ +#include "lp_lib.h" + +/* entries for lp structure */ +add_column_func *_add_column; +add_columnex_func *_add_columnex; +add_constraint_func *_add_constraint; +add_constraintex_func *_add_constraintex; +add_lag_con_func *_add_lag_con; +add_SOS_func *_add_SOS; +column_in_lp_func *_column_in_lp; +copy_lp_func *_copy_lp; +default_basis_func *_default_basis; +del_column_func *_del_column; +del_constraint_func *_del_constraint; +delete_lp_func *_delete_lp; +dualize_lp_func *_dualize_lp; +free_lp_func *_free_lp; +get_anti_degen_func *_get_anti_degen; +get_basis_func *_get_basis; +get_basiscrash_func *_get_basiscrash; +get_bb_depthlimit_func *_get_bb_depthlimit; +get_bb_floorfirst_func *_get_bb_floorfirst; +get_bb_rule_func *_get_bb_rule; +get_bounds_tighter_func *_get_bounds_tighter; +get_break_at_value_func *_get_break_at_value; +get_col_name_func *_get_col_name; +get_columnex_func *_get_columnex; +get_constr_type_func *_get_constr_type; +get_constr_value_func *_get_constr_value; +get_constraints_func *_get_constraints; +get_dual_solution_func *_get_dual_solution; +get_epsb_func *_get_epsb; +get_epsd_func *_get_epsd; +get_epsel_func *_get_epsel; +get_epsint_func *_get_epsint; +get_epsperturb_func *_get_epsperturb; +get_epspivot_func *_get_epspivot; +get_improve_func *_get_improve; +get_infinite_func *_get_infinite; +get_lambda_func *_get_lambda; +get_lowbo_func *_get_lowbo; +get_lp_index_func *_get_lp_index; +get_lp_name_func *_get_lp_name; +get_Lrows_func *_get_Lrows; +get_mat_func *_get_mat; +get_mat_byindex_func *_get_mat_byindex; +get_max_level_func *_get_max_level; +get_maxpivot_func *_get_maxpivot; +get_mip_gap_func *_get_mip_gap; +get_multiprice_func *_get_multiprice; +get_nameindex_func *_get_nameindex; +get_Ncolumns_func *_get_Ncolumns; +get_negrange_func *_get_negrange; +get_nz_func *_get_nonzeros; +get_Norig_columns_func *_get_Norig_columns; +get_Norig_rows_func *_get_Norig_rows; +get_Nrows_func *_get_Nrows; +get_obj_bound_func *_get_obj_bound; +get_objective_func *_get_objective; +get_orig_index_func *_get_orig_index; +get_origcol_name_func *_get_origcol_name; +get_origrow_name_func *_get_origrow_name; +get_partialprice_func *_get_partialprice; +get_pivoting_func *_get_pivoting; +get_presolve_func *_get_presolve; +get_presolveloops_func *_get_presolveloops; +get_primal_solution_func *_get_primal_solution; +get_print_sol_func *_get_print_sol; +get_pseudocosts_func *_get_pseudocosts; +get_ptr_constraints_func *_get_ptr_constraints; +get_ptr_dual_solution_func *_get_ptr_dual_solution; +get_ptr_lambda_func *_get_ptr_lambda; +get_ptr_primal_solution_func *_get_ptr_primal_solution; +get_ptr_sensitivity_obj_func *_get_ptr_sensitivity_obj; +get_ptr_sensitivity_objex_func *_get_ptr_sensitivity_objex; +get_ptr_sensitivity_rhs_func *_get_ptr_sensitivity_rhs; +get_ptr_variables_func *_get_ptr_variables; +get_rh_func *_get_rh; +get_rh_range_func *_get_rh_range; +get_row_func *_get_row; +get_row_name_func *_get_row_name; +get_scalelimit_func *_get_scalelimit; +get_scaling_func *_get_scaling; +get_sensitivity_obj_func *_get_sensitivity_obj; +get_sensitivity_objex_func *_get_sensitivity_objex; +get_sensitivity_rhs_func *_get_sensitivity_rhs; +get_simplextype_func *_get_simplextype; +get_solutioncount_func *_get_solutioncount; +get_solutionlimit_func *_get_solutionlimit; +get_status_func *_get_status; +get_statustext_func *_get_statustext; +get_timeout_func *_get_timeout; +get_total_iter_func *_get_total_iter; +get_total_nodes_func *_get_total_nodes; +get_upbo_func *_get_upbo; +get_var_branch_func *_get_var_branch; +get_var_dualresult_func *_get_var_dualresult; +get_var_primalresult_func *_get_var_primalresult; +get_var_priority_func *_get_var_priority; +get_variables_func *_get_variables; +get_verbose_func *_get_verbose; +get_working_objective_func *_get_working_objective; +has_BFP_func *_has_BFP; +has_XLI_func *_has_XLI; +is_add_rowmode_func *_is_add_rowmode; +is_anti_degen_func *_is_anti_degen; +is_binary_func *_is_binary; +is_break_at_first_func *_is_break_at_first; +is_constr_type_func *_is_constr_type; +is_debug_func *_is_debug; +is_feasible_func *_is_feasible; +is_unbounded_func *_is_unbounded; +is_infinite_func *_is_infinite; +is_int_func *_is_int; +is_integerscaling_func *_is_integerscaling; +is_lag_trace_func *_is_lag_trace; +is_maxim_func *_is_maxim; +is_nativeBFP_func *_is_nativeBFP; +is_nativeXLI_func *_is_nativeXLI; +is_negative_func *_is_negative; +is_piv_mode_func *_is_piv_mode; +is_piv_rule_func *_is_piv_rule; +is_presolve_func *_is_presolve; +is_scalemode_func *_is_scalemode; +is_scaletype_func *_is_scaletype; +is_semicont_func *_is_semicont; +is_SOS_var_func *_is_SOS_var; +is_trace_func *_is_trace; +lp_solve_version_func *_lp_solve_version; +make_lp_func *_make_lp; +print_constraints_func *_print_constraints; +print_debugdump_func *_print_debugdump; +print_duals_func *_print_duals; +print_lp_func *_print_lp; +print_objective_func *_print_objective; +print_scales_func *_print_scales; +print_solution_func *_print_solution; +print_str_func *_print_str; +print_tableau_func *_print_tableau; +put_abortfunc_func *_put_abortfunc; +put_bb_nodefunc_func *_put_bb_nodefunc; +put_bb_branchfunc_func *_put_bb_branchfunc; +put_logfunc_func *_put_logfunc; +put_msgfunc_func *_put_msgfunc; +read_LPhandle_func *_read_LPhandle; +read_MPShandle_func *_read_MPShandle; +read_XLI_func *_read_XLI; +read_params_func *_read_params; +read_basis_func *_read_basis; +reset_basis_func *_reset_basis; +reset_params_func *_reset_params; +resize_lp_func *_resize_lp; +set_add_rowmode_func *_set_add_rowmode; +set_anti_degen_func *_set_anti_degen; +set_basisvar_func *_set_basisvar; +set_basis_func *_set_basis; +set_basiscrash_func *_set_basiscrash; +set_bb_depthlimit_func *_set_bb_depthlimit; +set_bb_floorfirst_func *_set_bb_floorfirst; +set_bb_rule_func *_set_bb_rule; +set_BFP_func *_set_BFP; +set_binary_func *_set_binary; +set_bounds_func *_set_bounds; +set_bounds_tighter_func *_set_bounds_tighter; +set_break_at_first_func *_set_break_at_first; +set_break_at_value_func *_set_break_at_value; +set_column_func *_set_column; +set_columnex_func *_set_columnex; +set_col_name_func *_set_col_name; +set_constr_type_func *_set_constr_type; +set_debug_func *_set_debug; +set_epsb_func *_set_epsb; +set_epsd_func *_set_epsd; +set_epsel_func *_set_epsel; +set_epsint_func *_set_epsint; +set_epslevel_func *_set_epslevel; +set_epsperturb_func *_set_epsperturb; +set_epspivot_func *_set_epspivot; +set_unbounded_func *_set_unbounded; +set_improve_func *_set_improve; +set_infinite_func *_set_infinite; +set_int_func *_set_int; +set_lag_trace_func *_set_lag_trace; +set_lowbo_func *_set_lowbo; +set_lp_name_func *_set_lp_name; +set_mat_func *_set_mat; +set_maxim_func *_set_maxim; +set_maxpivot_func *_set_maxpivot; +set_minim_func *_set_minim; +set_mip_gap_func *_set_mip_gap; +set_multiprice_func *_set_multiprice; +set_negrange_func *_set_negrange; +set_obj_bound_func *_set_obj_bound; +set_obj_fn_func *_set_obj_fn; +set_obj_fnex_func *_set_obj_fnex; +set_obj_func *_set_obj; +set_outputfile_func *_set_outputfile; +set_outputstream_func *_set_outputstream; +set_partialprice_func *_set_partialprice; +set_pivoting_func *_set_pivoting; +set_preferdual_func *_set_preferdual; +set_presolve_func *_set_presolve; +set_print_sol_func *_set_print_sol; +set_pseudocosts_func *_set_pseudocosts; +set_rh_func *_set_rh; +set_rh_range_func *_set_rh_range; +set_rh_vec_func *_set_rh_vec; +set_row_func *_set_row; +set_rowex_func *_set_rowex; +set_row_name_func *_set_row_name; +set_scalelimit_func *_set_scalelimit; +set_scaling_func *_set_scaling; +set_semicont_func *_set_semicont; +set_sense_func *_set_sense; +set_simplextype_func *_set_simplextype; +set_solutionlimit_func *_set_solutionlimit; +set_timeout_func *_set_timeout; +set_trace_func *_set_trace; +set_upbo_func *_set_upbo; +set_var_branch_func *_set_var_branch; +set_var_weights_func *_set_var_weights; +set_verbose_func *_set_verbose; +set_XLI_func *_set_XLI; +solve_func *_solve; +str_add_column_func *_str_add_column; +str_add_constraint_func *_str_add_constraint; +str_add_lag_con_func *_str_add_lag_con; +str_set_obj_fn_func *_str_set_obj_fn; +str_set_rh_vec_func *_str_set_rh_vec; +time_elapsed_func *_time_elapsed; +unscale_func *_unscale; +write_lp_func *_write_lp; +write_LP_func *_write_LP; +write_mps_func *_write_mps; +write_MPS_func *_write_MPS; +write_freemps_func *_write_freemps; +write_freeMPS_func *_write_freeMPS; +write_XLI_func *_write_XLI; +write_basis_func *_write_basis; +write_params_func *_write_params; + +#if defined LPSOLVEAPIFROMLPREC + +static int init_lpsolve(lprec *lp) +{ + _add_column = lp->add_column; + _add_columnex = lp->add_columnex; + _add_constraint = lp->add_constraint; + _add_constraintex = lp->add_constraintex; + _add_lag_con = lp->add_lag_con; + _add_SOS = lp->add_SOS; + _column_in_lp = lp->column_in_lp; + _copy_lp = lp->copy_lp; + _default_basis = lp->default_basis; + _del_column = lp->del_column; + _del_constraint = lp->del_constraint; + _delete_lp = lp->delete_lp; + _dualize_lp = lp->dualize_lp; + _free_lp = lp->free_lp; + _get_anti_degen = lp->get_anti_degen; + _get_basis = lp->get_basis; + _get_basiscrash = lp->get_basiscrash; + _get_bb_depthlimit = lp->get_bb_depthlimit; + _get_bb_floorfirst = lp->get_bb_floorfirst; + _get_bb_rule = lp->get_bb_rule; + _get_bounds_tighter = lp->get_bounds_tighter; + _get_break_at_value = lp->get_break_at_value; + _get_col_name = lp->get_col_name; + _get_columnex = lp->get_columnex; + _get_constr_type = lp->get_constr_type; + _get_constr_value = lp->get_constr_value; + _get_constraints = lp->get_constraints; + _get_dual_solution = lp->get_dual_solution; + _get_epsb = lp->get_epsb; + _get_epsd = lp->get_epsd; + _get_epsel = lp->get_epsel; + _get_epsint = lp->get_epsint; + _get_epsperturb = lp->get_epsperturb; + _get_epspivot = lp->get_epspivot; + _get_improve = lp->get_improve; + _get_infinite = lp->get_infinite; + _get_lambda = lp->get_lambda; + _get_lowbo = lp->get_lowbo; + _get_lp_index = lp->get_lp_index; + _get_lp_name = lp->get_lp_name; + _get_Lrows = lp->get_Lrows; + _get_mat = lp->get_mat; + _get_mat_byindex = lp->get_mat_byindex; + _get_max_level = lp->get_max_level; + _get_maxpivot = lp->get_maxpivot; + _get_mip_gap = lp->get_mip_gap; + _get_multiprice = lp->get_multiprice; + _get_nameindex = lp->get_nameindex; + _get_Ncolumns = lp->get_Ncolumns; + _get_negrange = lp->get_negrange; + _get_nonzeros = lp->get_nonzeros; + _get_Norig_columns = lp->get_Norig_columns; + _get_Norig_rows = lp->get_Norig_rows; + _get_Nrows = lp->get_Nrows; + _get_obj_bound = lp->get_obj_bound; + _get_objective = lp->get_objective; + _get_orig_index = lp->get_orig_index; + _get_origcol_name = lp->get_origcol_name; + _get_origrow_name = lp->get_origrow_name; + _get_partialprice = lp->get_partialprice; + _get_pivoting = lp->get_pivoting; + _get_presolve = lp->get_presolve; + _get_presolveloops = lp->get_presolveloops; + _get_primal_solution = lp->get_primal_solution; + _get_print_sol = lp->get_print_sol; + _get_pseudocosts = lp->get_pseudocosts; + _get_ptr_constraints = lp->get_ptr_constraints; + _get_ptr_dual_solution = lp->get_ptr_dual_solution; + _get_ptr_lambda = lp->get_ptr_lambda; + _get_ptr_primal_solution = lp->get_ptr_primal_solution; + _get_ptr_sensitivity_obj = lp->get_ptr_sensitivity_obj; + _get_ptr_sensitivity_objex = lp->get_ptr_sensitivity_objex; + _get_ptr_sensitivity_rhs = lp->get_ptr_sensitivity_rhs; + _get_ptr_variables = lp->get_ptr_variables; + _get_rh = lp->get_rh; + _get_rh_range = lp->get_rh_range; + _get_row = lp->get_row; + _get_row_name = lp->get_row_name; + _get_scalelimit = lp->get_scalelimit; + _get_scaling = lp->get_scaling; + _get_sensitivity_obj = lp->get_sensitivity_obj; + _get_sensitivity_objex = lp->get_sensitivity_objex; + _get_sensitivity_rhs = lp->get_sensitivity_rhs; + _get_simplextype = lp->get_simplextype; + _get_solutioncount = lp->get_solutioncount; + _get_solutionlimit = lp->get_solutionlimit; + _get_status = lp->get_status; + _get_statustext = lp->get_statustext; + _get_timeout = lp->get_timeout; + _get_total_iter = lp->get_total_iter; + _get_total_nodes = lp->get_total_nodes; + _get_upbo = lp->get_upbo; + _get_var_branch = lp->get_var_branch; + _get_var_dualresult = lp->get_var_dualresult; + _get_var_primalresult = lp->get_var_primalresult; + _get_var_priority = lp->get_var_priority; + _get_variables = lp->get_variables; + _get_verbose = lp->get_verbose; + _get_working_objective = lp->get_working_objective; + _has_BFP = lp->has_BFP; + _has_XLI = lp->has_XLI; + _is_add_rowmode = lp->is_add_rowmode; + _is_anti_degen = lp->is_anti_degen; + _is_binary = lp->is_binary; + _is_break_at_first = lp->is_break_at_first; + _is_constr_type = lp->is_constr_type; + _is_debug = lp->is_debug; + _is_feasible = lp->is_feasible; + _is_unbounded = lp->is_unbounded; + _is_infinite = lp->is_infinite; + _is_int = lp->is_int; + _is_integerscaling = lp->is_integerscaling; + _is_lag_trace = lp->is_lag_trace; + _is_maxim = lp->is_maxim; + _is_nativeBFP = lp->is_nativeBFP; + _is_nativeXLI = lp->is_nativeXLI; + _is_negative = lp->is_negative; + _is_piv_mode = lp->is_piv_mode; + _is_piv_rule = lp->is_piv_rule; + _is_presolve = lp->is_presolve; + _is_scalemode = lp->is_scalemode; + _is_scaletype = lp->is_scaletype; + _is_semicont = lp->is_semicont; + _is_SOS_var = lp->is_SOS_var; + _is_trace = lp->is_trace; + _lp_solve_version = lp->lp_solve_version; + _make_lp = lp->make_lp; + _print_constraints = lp->print_constraints; + _print_debugdump = lp->print_debugdump; + _print_duals = lp->print_duals; + _print_lp = lp->print_lp; + _print_objective = lp->print_objective; + _print_scales = lp->print_scales; + _print_solution = lp->print_solution; + _print_str = lp->print_str; + _print_tableau = lp->print_tableau; + _put_abortfunc = lp->put_abortfunc; + _put_bb_nodefunc = lp->put_bb_nodefunc; + _put_bb_branchfunc = lp->put_bb_branchfunc; + _put_logfunc = lp->put_logfunc; + _put_msgfunc = lp->put_msgfunc; + _read_LPhandle = lp->read_LPhandle; + _read_MPShandle = lp->read_MPShandle; + _read_XLI = lp->read_XLI; + _read_params = lp->read_params; + _read_basis = lp->read_basis; + _reset_basis = lp->reset_basis; + _reset_params = lp->reset_params; + _resize_lp = lp->resize_lp; + _set_add_rowmode = lp->set_add_rowmode; + _set_anti_degen = lp->set_anti_degen; + _set_basisvar = lp->set_basisvar; + _set_basis = lp->set_basis; + _set_basiscrash = lp->set_basiscrash; + _set_bb_depthlimit = lp->set_bb_depthlimit; + _set_bb_floorfirst = lp->set_bb_floorfirst; + _set_bb_rule = lp->set_bb_rule; + _set_BFP = lp->set_BFP; + _set_binary = lp->set_binary; + _set_bounds = lp->set_bounds; + _set_bounds_tighter = lp->set_bounds_tighter; + _set_break_at_first = lp->set_break_at_first; + _set_break_at_value = lp->set_break_at_value; + _set_column = lp->set_column; + _set_columnex = lp->set_columnex; + _set_col_name = lp->set_col_name; + _set_constr_type = lp->set_constr_type; + _set_debug = lp->set_debug; + _set_epsb = lp->set_epsb; + _set_epsd = lp->set_epsd; + _set_epsel = lp->set_epsel; + _set_epsint = lp->set_epsint; + _set_epslevel = lp->set_epslevel; + _set_epsperturb = lp->set_epsperturb; + _set_epspivot = lp->set_epspivot; + _set_unbounded = lp->set_unbounded; + _set_improve = lp->set_improve; + _set_infinite = lp->set_infinite; + _set_int = lp->set_int; + _set_lag_trace = lp->set_lag_trace; + _set_lowbo = lp->set_lowbo; + _set_lp_name = lp->set_lp_name; + _set_mat = lp->set_mat; + _set_maxim = lp->set_maxim; + _set_maxpivot = lp->set_maxpivot; + _set_minim = lp->set_minim; + _set_mip_gap = lp->set_mip_gap; + _set_multiprice = lp->set_multiprice; + _set_negrange = lp->set_negrange; + _set_obj_bound = lp->set_obj_bound; + _set_obj_fn = lp->set_obj_fn; + _set_obj_fnex = lp->set_obj_fnex; + _set_obj = lp->set_obj; + _set_outputfile = lp->set_outputfile; + _set_outputstream = lp->set_outputstream; + _set_partialprice = lp->set_partialprice; + _set_pivoting = lp->set_pivoting; + _set_preferdual = lp->set_preferdual; + _set_presolve = lp->set_presolve; + _set_print_sol = lp->set_print_sol; + _set_pseudocosts = lp->set_pseudocosts; + _set_rh = lp->set_rh; + _set_rh_range = lp->set_rh_range; + _set_rh_vec = lp->set_rh_vec; + _set_row = lp->set_row; + _set_rowex = lp->set_rowex; + _set_row_name = lp->set_row_name; + _set_scalelimit = lp->set_scalelimit; + _set_scaling = lp->set_scaling; + _set_semicont = lp->set_semicont; + _set_sense = lp->set_sense; + _set_simplextype = lp->set_simplextype; + _set_solutionlimit = lp->set_solutionlimit; + _set_timeout = lp->set_timeout; + _set_trace = lp->set_trace; + _set_upbo = lp->set_upbo; + _set_var_branch = lp->set_var_branch; + _set_var_weights = lp->set_var_weights; + _set_verbose = lp->set_verbose; + _set_XLI = lp->set_XLI; + _solve = lp->solve; + _str_add_column = lp->str_add_column; + _str_add_constraint = lp->str_add_constraint; + _str_add_lag_con = lp->str_add_lag_con; + _str_set_obj_fn = lp->str_set_obj_fn; + _str_set_rh_vec = lp->str_set_rh_vec; + _time_elapsed = lp->time_elapsed; + _unscale = lp->unscale; + _write_lp = lp->write_lp; + _write_LP = lp->write_LP; + _write_mps = lp->write_mps; + _write_MPS = lp->write_MPS; + _write_freemps = lp->write_freemps; + _write_freeMPS = lp->write_freeMPS; + _write_XLI = lp->write_XLI; + _write_basis = lp->write_basis; + _write_params = lp->write_params; + + return(TRUE); +} + +#elif defined LPSOLVEAPIFROMLIB + +#ifdef WIN32 +# include +#else +# include +#endif + +#if defined WIN32 +# define hlpsolve HINSTANCE +#else +# define hlpsolve void * +#endif + +static hlpsolve open_lpsolve_lib(char *filename) +{ + hlpsolve lpsolve; + +# if defined WIN32 + /* Get a handle to the Windows DLL module. */ + lpsolve = LoadLibrary("lpsolve55.dll"); +# else + lpsolve = dlopen("liblpsolve55.so", RTLD_LAZY);; +# endif + return(lpsolve); +} + +static int close_lpsolve_lib(hlpsolve lpsolve) +{ +#ifdef WIN32 + FreeLibrary(lpsolve); +#else + dlclose(lpsolve); +#endif + + return(TRUE); +} + +static int init_lpsolve(hlpsolve lpsolve) +{ +# if defined WIN32 +# define AddressOf GetProcAddress +# else +# define AddressOf dlsym +# endif + + /* assign API functions to lp structure */ + _add_column = (add_column_func *) AddressOf(lpsolve, "add_column"); + _add_columnex = (add_columnex_func *) AddressOf(lpsolve, "add_columnex"); + _add_constraint = (add_constraint_func *) AddressOf(lpsolve, "add_constraint"); + _add_constraintex = (add_constraintex_func *) AddressOf(lpsolve, "add_constraintex"); + _add_lag_con = (add_lag_con_func *) AddressOf(lpsolve, "add_lag_con"); + _add_SOS = (add_SOS_func *) AddressOf(lpsolve, "add_SOS"); + _column_in_lp = (column_in_lp_func *) AddressOf(lpsolve, "column_in_lp"); + _copy_lp = (copy_lp_func *) AddressOf(lpsolve, "copy_lp"); + _default_basis = (default_basis_func *) AddressOf(lpsolve, "default_basis"); + _del_column = (del_column_func *) AddressOf(lpsolve, "del_column"); + _del_constraint = (del_constraint_func *) AddressOf(lpsolve, "del_constraint"); + _delete_lp = (delete_lp_func *) AddressOf(lpsolve, "delete_lp"); + _dualize_lp = (dualize_lp_func *) AddressOf(lpsolve, "dualize_lp"); + _free_lp = (free_lp_func *) AddressOf(lpsolve, "free_lp"); + _get_anti_degen = (get_anti_degen_func *) AddressOf(lpsolve, "get_anti_degen"); + _get_basis = (get_basis_func *) AddressOf(lpsolve, "get_basis"); + _get_basiscrash = (get_basiscrash_func *) AddressOf(lpsolve, "get_basiscrash"); + _get_bb_depthlimit = (get_bb_depthlimit_func *) AddressOf(lpsolve, "get_bb_depthlimit"); + _get_bb_floorfirst = (get_bb_floorfirst_func *) AddressOf(lpsolve, "get_bb_floorfirst"); + _get_bb_rule = (get_bb_rule_func *) AddressOf(lpsolve, "get_bb_rule"); + _get_bounds_tighter = (get_bounds_tighter_func *) AddressOf(lpsolve, "get_bounds_tighter"); + _get_break_at_value = (get_break_at_value_func *) AddressOf(lpsolve, "get_break_at_value"); + _get_col_name = (get_col_name_func *) AddressOf(lpsolve, "get_col_name"); + _get_columnex = (get_columnex_func *) AddressOf(lpsolve, "get_columnex"); + _get_constr_type = (get_constr_type_func *) AddressOf(lpsolve, "get_constr_type"); + _get_constr_value = (get_constr_value_func *) AddressOf(lpsolve, "get_constr_value"); + _get_constraints = (get_constraints_func *) AddressOf(lpsolve, "get_constraints"); + _get_dual_solution = (get_dual_solution_func *) AddressOf(lpsolve, "get_dual_solution"); + _get_epsb = (get_epsb_func *) AddressOf(lpsolve, "get_epsb"); + _get_epsd = (get_epsd_func *) AddressOf(lpsolve, "get_epsd"); + _get_epsel = (get_epsel_func *) AddressOf(lpsolve, "get_epsel"); + _get_epsint = (get_epsint_func *) AddressOf(lpsolve, "get_epsint"); + _get_epsperturb = (get_epsperturb_func *) AddressOf(lpsolve, "get_epsperturb"); + _get_epspivot = (get_epspivot_func *) AddressOf(lpsolve, "get_epspivot"); + _get_improve = (get_improve_func *) AddressOf(lpsolve, "get_improve"); + _get_infinite = (get_infinite_func *) AddressOf(lpsolve, "get_infinite"); + _get_lambda = (get_lambda_func *) AddressOf(lpsolve, "get_lambda"); + _get_lowbo = (get_lowbo_func *) AddressOf(lpsolve, "get_lowbo"); + _get_lp_index = (get_lp_index_func *) AddressOf(lpsolve, "get_lp_index"); + _get_lp_name = (get_lp_name_func *) AddressOf(lpsolve, "get_lp_name"); + _get_Lrows = (get_Lrows_func *) AddressOf(lpsolve, "get_Lrows"); + _get_mat = (get_mat_func *) AddressOf(lpsolve, "get_mat"); + _get_mat_byindex = (get_mat_byindex_func *) AddressOf(lpsolve, "get_mat_byindex"); + _get_max_level = (get_max_level_func *) AddressOf(lpsolve, "get_max_level"); + _get_maxpivot = (get_maxpivot_func *) AddressOf(lpsolve, "get_maxpivot"); + _get_mip_gap = (get_mip_gap_func *) AddressOf(lpsolve, "get_mip_gap"); + _get_multiprice = (get_multiprice_func *) AddressOf(lpsolve, "get_multiprice"); + _get_nameindex = (get_nameindex_func *) AddressOf(lpsolve, "get_nameindex"); + _get_Ncolumns = (get_Ncolumns_func *) AddressOf(lpsolve, "get_Ncolumns"); + _get_negrange = (get_negrange_func *) AddressOf(lpsolve, "get_negrange"); + _get_nonzeros = (get_nz_func *) AddressOf(lpsolve, "get_nonzeros"); + _get_Norig_columns = (get_Norig_columns_func *) AddressOf(lpsolve, "get_Norig_columns"); + _get_Norig_rows = (get_Norig_rows_func *) AddressOf(lpsolve, "get_Norig_rows"); + _get_Nrows = (get_Nrows_func *) AddressOf(lpsolve, "get_Nrows"); + _get_obj_bound = (get_obj_bound_func *) AddressOf(lpsolve, "get_obj_bound"); + _get_objective = (get_objective_func *) AddressOf(lpsolve, "get_objective"); + _get_orig_index = (get_orig_index_func *) AddressOf(lpsolve, "get_orig_index"); + _get_origcol_name = (get_origcol_name_func *) AddressOf(lpsolve, "get_origcol_name"); + _get_origrow_name = (get_origrow_name_func *) AddressOf(lpsolve, "get_origrow_name"); + _get_partialprice = (get_partialprice_func *) AddressOf(lpsolve, "get_partialprice"); + _get_pivoting = (get_pivoting_func *) AddressOf(lpsolve, "get_pivoting"); + _get_presolve = (get_presolve_func *) AddressOf(lpsolve, "get_presolve"); + _get_presolveloops = (get_presolveloops_func *) AddressOf(lpsolve, "get_presolveloops"); + _get_primal_solution = (get_primal_solution_func *) AddressOf(lpsolve, "get_primal_solution"); + _get_print_sol = (get_print_sol_func *) AddressOf(lpsolve, "get_print_sol"); + _get_pseudocosts = (get_pseudocosts_func *) AddressOf(lpsolve, "get_pseudocosts"); + _get_ptr_constraints = (get_ptr_constraints_func *) AddressOf(lpsolve, "get_ptr_constraints"); + _get_ptr_dual_solution = (get_ptr_dual_solution_func *) AddressOf(lpsolve, "get_ptr_dual_solution"); + _get_ptr_lambda = (get_ptr_lambda_func *) AddressOf(lpsolve, "get_ptr_lambda"); + _get_ptr_primal_solution = (get_ptr_primal_solution_func *) AddressOf(lpsolve, "get_ptr_primal_solution"); + _get_ptr_sensitivity_obj = (get_ptr_sensitivity_obj_func *) AddressOf(lpsolve, "get_ptr_sensitivity_obj"); + _get_ptr_sensitivity_objex = (get_ptr_sensitivity_objex_func *) AddressOf(lpsolve, "get_ptr_sensitivity_objex"); + _get_ptr_sensitivity_rhs = (get_ptr_sensitivity_rhs_func *) AddressOf(lpsolve, "get_ptr_sensitivity_rhs"); + _get_ptr_variables = (get_ptr_variables_func *) AddressOf(lpsolve, "get_ptr_variables"); + _get_rh = (get_rh_func *) AddressOf(lpsolve, "get_rh"); + _get_rh_range = (get_rh_range_func *) AddressOf(lpsolve, "get_rh_range"); + _get_row = (get_row_func *) AddressOf(lpsolve, "get_row"); + _get_row_name = (get_row_name_func *) AddressOf(lpsolve, "get_row_name"); + _get_scalelimit = (get_scalelimit_func *) AddressOf(lpsolve, "get_scalelimit"); + _get_scaling = (get_scaling_func *) AddressOf(lpsolve, "get_scaling"); + _get_sensitivity_obj = (get_sensitivity_obj_func *) AddressOf(lpsolve, "get_sensitivity_obj"); + _get_sensitivity_objex = (get_sensitivity_objex_func *) AddressOf(lpsolve, "get_sensitivity_objex"); + _get_sensitivity_rhs = (get_sensitivity_rhs_func *) AddressOf(lpsolve, "get_sensitivity_rhs"); + _get_simplextype = (get_simplextype_func *) AddressOf(lpsolve, "get_simplextype"); + _get_solutioncount = (get_solutioncount_func *) AddressOf(lpsolve, "get_solutioncount"); + _get_solutionlimit = (get_solutionlimit_func *) AddressOf(lpsolve, "get_solutionlimit"); + _get_status = (get_status_func *) AddressOf(lpsolve, "get_status"); + _get_statustext = (get_statustext_func *) AddressOf(lpsolve, "get_statustext"); + _get_timeout = (get_timeout_func *) AddressOf(lpsolve, "get_timeout"); + _get_total_iter = (get_total_iter_func *) AddressOf(lpsolve, "get_total_iter"); + _get_total_nodes = (get_total_nodes_func *) AddressOf(lpsolve, "get_total_nodes"); + _get_upbo = (get_upbo_func *) AddressOf(lpsolve, "get_upbo"); + _get_var_branch = (get_var_branch_func *) AddressOf(lpsolve, "get_var_branch"); + _get_var_dualresult = (get_var_dualresult_func *) AddressOf(lpsolve, "get_var_dualresult"); + _get_var_primalresult = (get_var_primalresult_func *) AddressOf(lpsolve, "get_var_primalresult"); + _get_var_priority = (get_var_priority_func *) AddressOf(lpsolve, "get_var_priority"); + _get_variables = (get_variables_func *) AddressOf(lpsolve, "get_variables"); + _get_verbose = (get_verbose_func *) AddressOf(lpsolve, "get_verbose"); + _get_working_objective = (get_working_objective_func *) AddressOf(lpsolve, "get_working_objective"); + _has_BFP = (has_BFP_func *) AddressOf(lpsolve, "has_BFP"); + _has_XLI = (has_XLI_func *) AddressOf(lpsolve, "has_XLI"); + _is_add_rowmode = (is_add_rowmode_func *) AddressOf(lpsolve, "is_add_rowmode"); + _is_anti_degen = (is_anti_degen_func *) AddressOf(lpsolve, "is_anti_degen"); + _is_binary = (is_binary_func *) AddressOf(lpsolve, "is_binary"); + _is_break_at_first = (is_break_at_first_func *) AddressOf(lpsolve, "is_break_at_first"); + _is_constr_type = (is_constr_type_func *) AddressOf(lpsolve, "is_constr_type"); + _is_debug = (is_debug_func *) AddressOf(lpsolve, "is_debug"); + _is_feasible = (is_feasible_func *) AddressOf(lpsolve, "is_feasible"); + _is_unbounded = (is_unbounded_func *) AddressOf(lpsolve, "is_unbounded"); + _is_infinite = (is_infinite_func *) AddressOf(lpsolve, "is_infinite"); + _is_int = (is_int_func *) AddressOf(lpsolve, "is_int"); + _is_integerscaling = (is_integerscaling_func *) AddressOf(lpsolve, "is_integerscaling"); + _is_lag_trace = (is_lag_trace_func *) AddressOf(lpsolve, "is_lag_trace"); + _is_maxim = (is_maxim_func *) AddressOf(lpsolve, "is_maxim"); + _is_nativeBFP = (is_nativeBFP_func *) AddressOf(lpsolve, "is_nativeBFP"); + _is_nativeXLI = (is_nativeXLI_func *) AddressOf(lpsolve, "is_nativeXLI"); + _is_negative = (is_negative_func *) AddressOf(lpsolve, "is_negative"); + _is_piv_mode = (is_piv_mode_func *) AddressOf(lpsolve, "is_piv_mode"); + _is_piv_rule = (is_piv_rule_func *) AddressOf(lpsolve, "is_piv_rule"); + _is_presolve = (is_presolve_func *) AddressOf(lpsolve, "is_presolve"); + _is_scalemode = (is_scalemode_func *) AddressOf(lpsolve, "is_scalemode"); + _is_scaletype = (is_scaletype_func *) AddressOf(lpsolve, "is_scaletype"); + _is_semicont = (is_semicont_func *) AddressOf(lpsolve, "is_semicont"); + _is_SOS_var = (is_SOS_var_func *) AddressOf(lpsolve, "is_SOS_var"); + _is_trace = (is_trace_func *) AddressOf(lpsolve, "is_trace"); + _lp_solve_version = (lp_solve_version_func *) AddressOf(lpsolve, "lp_solve_version"); + _make_lp = (make_lp_func *) AddressOf(lpsolve, "make_lp"); + _print_constraints = (print_constraints_func *) AddressOf(lpsolve, "print_constraints"); + _print_debugdump = (print_debugdump_func *) AddressOf(lpsolve, "print_debugdump"); + _print_duals = (print_duals_func *) AddressOf(lpsolve, "print_duals"); + _print_lp = (print_lp_func *) AddressOf(lpsolve, "print_lp"); + _print_objective = (print_objective_func *) AddressOf(lpsolve, "print_objective"); + _print_scales = (print_scales_func *) AddressOf(lpsolve, "print_scales"); + _print_solution = (print_solution_func *) AddressOf(lpsolve, "print_solution"); + _print_str = (print_str_func *) AddressOf(lpsolve, "print_str"); + _print_tableau = (print_tableau_func *) AddressOf(lpsolve, "print_tableau"); + _put_abortfunc = (put_abortfunc_func *) AddressOf(lpsolve, "put_abortfunc"); + _put_bb_nodefunc = (put_bb_nodefunc_func *) AddressOf(lpsolve, "put_bb_nodefunc"); + _put_bb_branchfunc = (put_bb_branchfunc_func *) AddressOf(lpsolve, "put_bb_branchfunc"); + _put_logfunc = (put_logfunc_func *) AddressOf(lpsolve, "put_logfunc"); + _put_msgfunc = (put_msgfunc_func *) AddressOf(lpsolve, "put_msgfunc"); + _read_LPhandle = (read_LPhandle_func *) AddressOf(lpsolve, "read_LPhandle"); + _read_MPShandle = (read_MPShandle_func *) AddressOf(lpsolve, "read_MPShandle"); + _read_XLI = (read_XLI_func *) AddressOf(lpsolve, "read_XLI"); + _read_params = (read_params_func *) AddressOf(lpsolve, "read_params"); + _read_basis = (read_basis_func *) AddressOf(lpsolve, "read_basis"); + _reset_basis = (reset_basis_func *) AddressOf(lpsolve, "reset_basis"); + _reset_params = (reset_params_func *) AddressOf(lpsolve, "reset_params"); + _resize_lp = (resize_lp_func *) AddressOf(lpsolve, "resize_lp"); + _set_add_rowmode = (set_add_rowmode_func *) AddressOf(lpsolve, "set_add_rowmode"); + _set_anti_degen = (set_anti_degen_func *) AddressOf(lpsolve, "set_anti_degen"); + _set_basisvar = (set_basisvar_func *) AddressOf(lpsolve, "set_basisvar"); + _set_basis = (set_basis_func *) AddressOf(lpsolve, "set_basis"); + _set_basiscrash = (set_basiscrash_func *) AddressOf(lpsolve, "set_basiscrash"); + _set_bb_depthlimit = (set_bb_depthlimit_func *) AddressOf(lpsolve, "set_bb_depthlimit"); + _set_bb_floorfirst = (set_bb_floorfirst_func *) AddressOf(lpsolve, "set_bb_floorfirst"); + _set_bb_rule = (set_bb_rule_func *) AddressOf(lpsolve, "set_bb_rule"); + _set_BFP = (set_BFP_func *) AddressOf(lpsolve, "set_BFP"); + _set_binary = (set_binary_func *) AddressOf(lpsolve, "set_binary"); + _set_bounds = (set_bounds_func *) AddressOf(lpsolve, "set_bounds"); + _set_bounds_tighter = (set_bounds_tighter_func *) AddressOf(lpsolve, "set_bounds_tighter"); + _set_break_at_first = (set_break_at_first_func *) AddressOf(lpsolve, "set_break_at_first"); + _set_break_at_value = (set_break_at_value_func *) AddressOf(lpsolve, "set_break_at_value"); + _set_column = (set_column_func *) AddressOf(lpsolve, "set_column"); + _set_columnex = (set_columnex_func *) AddressOf(lpsolve, "set_columnex"); + _set_col_name = (set_col_name_func *) AddressOf(lpsolve, "set_col_name"); + _set_constr_type = (set_constr_type_func *) AddressOf(lpsolve, "set_constr_type"); + _set_debug = (set_debug_func *) AddressOf(lpsolve, "set_debug"); + _set_epsb = (set_epsb_func *) AddressOf(lpsolve, "set_epsb"); + _set_epsd = (set_epsd_func *) AddressOf(lpsolve, "set_epsd"); + _set_epsel = (set_epsel_func *) AddressOf(lpsolve, "set_epsel"); + _set_epsint = (set_epsint_func *) AddressOf(lpsolve, "set_epsint"); + _set_epslevel = (set_epslevel_func *) AddressOf(lpsolve, "set_epslevel"); + _set_epsperturb = (set_epsperturb_func *) AddressOf(lpsolve, "set_epsperturb"); + _set_epspivot = (set_epspivot_func *) AddressOf(lpsolve, "set_epspivot"); + _set_unbounded = (set_unbounded_func *) AddressOf(lpsolve, "set_unbounded"); + _set_improve = (set_improve_func *) AddressOf(lpsolve, "set_improve"); + _set_infinite = (set_infinite_func *) AddressOf(lpsolve, "set_infinite"); + _set_int = (set_int_func *) AddressOf(lpsolve, "set_int"); + _set_lag_trace = (set_lag_trace_func *) AddressOf(lpsolve, "set_lag_trace"); + _set_lowbo = (set_lowbo_func *) AddressOf(lpsolve, "set_lowbo"); + _set_lp_name = (set_lp_name_func *) AddressOf(lpsolve, "set_lp_name"); + _set_mat = (set_mat_func *) AddressOf(lpsolve, "set_mat"); + _set_maxim = (set_maxim_func *) AddressOf(lpsolve, "set_maxim"); + _set_maxpivot = (set_maxpivot_func *) AddressOf(lpsolve, "set_maxpivot"); + _set_minim = (set_minim_func *) AddressOf(lpsolve, "set_minim"); + _set_mip_gap = (set_mip_gap_func *) AddressOf(lpsolve, "set_mip_gap"); + _set_multiprice = (set_multiprice_func *) AddressOf(lpsolve, "set_multiprice"); + _set_negrange = (set_negrange_func *) AddressOf(lpsolve, "set_negrange"); + _set_obj_bound = (set_obj_bound_func *) AddressOf(lpsolve, "set_obj_bound"); + _set_obj_fn = (set_obj_fn_func *) AddressOf(lpsolve, "set_obj_fn"); + _set_obj_fnex = (set_obj_fnex_func *) AddressOf(lpsolve, "set_obj_fnex"); + _set_obj = (set_obj_func *) AddressOf(lpsolve, "set_obj"); + _set_outputfile = (set_outputfile_func *) AddressOf(lpsolve, "set_outputfile"); + _set_outputstream = (set_outputstream_func *) AddressOf(lpsolve, "set_outputstream"); + _set_partialprice = (set_partialprice_func *) AddressOf(lpsolve, "set_partialprice"); + _set_pivoting = (set_pivoting_func *) AddressOf(lpsolve, "set_pivoting"); + _set_preferdual = (set_preferdual_func *) AddressOf(lpsolve, "set_preferdual"); + _set_presolve = (set_presolve_func *) AddressOf(lpsolve, "set_presolve"); + _set_print_sol = (set_print_sol_func *) AddressOf(lpsolve, "set_print_sol"); + _set_pseudocosts = (set_pseudocosts_func *) AddressOf(lpsolve, "set_pseudocosts"); + _set_rh = (set_rh_func *) AddressOf(lpsolve, "set_rh"); + _set_rh_range = (set_rh_range_func *) AddressOf(lpsolve, "set_rh_range"); + _set_rh_vec = (set_rh_vec_func *) AddressOf(lpsolve, "set_rh_vec"); + _set_row = (set_row_func *) AddressOf(lpsolve, "set_row"); + _set_rowex = (set_rowex_func *) AddressOf(lpsolve, "set_rowex"); + _set_row_name = (set_row_name_func *) AddressOf(lpsolve, "set_row_name"); + _set_scalelimit = (set_scalelimit_func *) AddressOf(lpsolve, "set_scalelimit"); + _set_scaling = (set_scaling_func *) AddressOf(lpsolve, "set_scaling"); + _set_semicont = (set_semicont_func *) AddressOf(lpsolve, "set_semicont"); + _set_sense = (set_sense_func *) AddressOf(lpsolve, "set_sense"); + _set_simplextype = (set_simplextype_func *) AddressOf(lpsolve, "set_simplextype"); + _set_solutionlimit = (set_solutionlimit_func *) AddressOf(lpsolve, "set_solutionlimit"); + _set_timeout = (set_timeout_func *) AddressOf(lpsolve, "set_timeout"); + _set_trace = (set_trace_func *) AddressOf(lpsolve, "set_trace"); + _set_upbo = (set_upbo_func *) AddressOf(lpsolve, "set_upbo"); + _set_var_branch = (set_var_branch_func *) AddressOf(lpsolve, "set_var_branch"); + _set_var_weights = (set_var_weights_func *) AddressOf(lpsolve, "set_var_weights"); + _set_verbose = (set_verbose_func *) AddressOf(lpsolve, "set_verbose"); + _set_XLI = (set_XLI_func *) AddressOf(lpsolve, "set_XLI"); + _solve = (solve_func *) AddressOf(lpsolve, "solve"); + _str_add_column = (str_add_column_func *) AddressOf(lpsolve, "str_add_column"); + _str_add_constraint = (str_add_constraint_func *) AddressOf(lpsolve, "str_add_constraint"); + _str_add_lag_con = (str_add_lag_con_func *) AddressOf(lpsolve, "str_add_lag_con"); + _str_set_obj_fn = (str_set_obj_fn_func *) AddressOf(lpsolve, "str_set_obj_fn"); + _str_set_rh_vec = (str_set_rh_vec_func *) AddressOf(lpsolve, "str_set_rh_vec"); + _time_elapsed = (time_elapsed_func *) AddressOf(lpsolve, "time_elapsed"); + _unscale = (unscale_func *) AddressOf(lpsolve, "unscale"); + _write_lp = (write_lp_func *) AddressOf(lpsolve, "write_lp"); + _write_LP = (write_LP_func *) AddressOf(lpsolve, "write_LP"); + _write_mps = (write_mps_func *) AddressOf(lpsolve, "write_mps"); + _write_MPS = (write_MPS_func *) AddressOf(lpsolve, "write_MPS"); + _write_freemps = (write_freemps_func *) AddressOf(lpsolve, "write_freemps"); + _write_freeMPS = (write_freeMPS_func *) AddressOf(lpsolve, "write_freeMPS"); + _write_XLI = (write_XLI_func *) AddressOf(lpsolve, "write_XLI"); + _write_basis = (write_basis_func *) AddressOf(lpsolve, "write_basis"); + _write_params = (write_params_func *) AddressOf(lpsolve, "write_params"); + + return(TRUE); +# undef AddressOf +} + +#else +# error Either LPSOLVEAPIFROMLPREC or LPSOLVEAPIFROMLIB must be defined +#endif + +#define add_column _add_column +#define add_columnex _add_columnex +#define add_constraint _add_constraint +#define add_constraintex _add_constraintex +#define add_lag_con _add_lag_con +#define add_SOS _add_SOS +#define column_in_lp _column_in_lp +#define copy_lp _copy_lp +#define default_basis _default_basis +#define del_column _del_column +#define del_constraint _del_constraint +#define delete_lp _delete_lp +#define dualize_lp _dualize_lp +#define free_lp _free_lp +#define get_anti_degen _get_anti_degen +#define get_basis _get_basis +#define get_basiscrash _get_basiscrash +#define get_bb_depthlimit _get_bb_depthlimit +#define get_bb_floorfirst _get_bb_floorfirst +#define get_bb_rule _get_bb_rule +#define get_bounds_tighter _get_bounds_tighter +#define get_break_at_value _get_break_at_value +#define get_col_name _get_col_name +#define get_columnex _get_columnex +#define get_constr_type _get_constr_type +#define get_constr_value _get_constr_value +#define get_constraints _get_constraints +#define get_dual_solution _get_dual_solution +#define get_epsb _get_epsb +#define get_epsd _get_epsd +#define get_epsel _get_epsel +#define get_epsint _get_epsint +#define get_epsperturb _get_epsperturb +#define get_epspivot _get_epspivot +#define get_improve _get_improve +#define get_infinite _get_infinite +#define get_lambda _get_lambda +#define get_lowbo _get_lowbo +#define get_lp_index _get_lp_index +#define get_lp_name _get_lp_name +#define get_Lrows _get_Lrows +#define get_mat _get_mat +#define get_mat_byindex _get_mat_byindex +#define get_max_level _get_max_level +#define get_maxpivot _get_maxpivot +#define get_mip_gap _get_mip_gap +#define get_multiprice _get_multiprice +#define get_nameindex _get_nameindex +#define get_Ncolumns _get_Ncolumns +#define get_negrange _get_negrange +#define get_nonzeros _get_nonzeros +#define get_Norig_columns _get_Norig_columns +#define get_Norig_rows _get_Norig_rows +#define get_Nrows _get_Nrows +#define get_obj_bound _get_obj_bound +#define get_objective _get_objective +#define get_orig_index _get_orig_index +#define get_origcol_name _get_origcol_name +#define get_origrow_name _get_origrow_name +#define get_partialprice _get_partialprice +#define get_pivoting _get_pivoting +#define get_presolve _get_presolve +#define get_presolveloops _get_presolveloops +#define get_primal_solution _get_primal_solution +#define get_print_sol _get_print_sol +#define get_pseudocosts _get_pseudocosts +#define get_ptr_constraints _get_ptr_constraints +#define get_ptr_dual_solution _get_ptr_dual_solution +#define get_ptr_lambda _get_ptr_lambda +#define get_ptr_primal_solution _get_ptr_primal_solution +#define get_ptr_sensitivity_obj _get_ptr_sensitivity_obj +#define get_ptr_sensitivity_objex _get_ptr_sensitivity_objex +#define get_ptr_sensitivity_rhs _get_ptr_sensitivity_rhs +#define get_ptr_variables _get_ptr_variables +#define get_rh _get_rh +#define get_rh_range _get_rh_range +#define get_row _get_row +#define get_row_name _get_row_name +#define get_scalelimit _get_scalelimit +#define get_scaling _get_scaling +#define get_sensitivity_obj _get_sensitivity_obj +#define get_sensitivity_objex _get_sensitivity_objex +#define get_sensitivity_rhs _get_sensitivity_rhs +#define get_simplextype _get_simplextype +#define get_solutioncount _get_solutioncount +#define get_solutionlimit _get_solutionlimit +#define get_status _get_status +#define get_statustext _get_statustext +#define get_timeout _get_timeout +#define get_total_iter _get_total_iter +#define get_total_nodes _get_total_nodes +#define get_upbo _get_upbo +#define get_var_branch _get_var_branch +#define get_var_dualresult _get_var_dualresult +#define get_var_primalresult _get_var_primalresult +#define get_var_priority _get_var_priority +#define get_variables _get_variables +#define get_verbose _get_verbose +#define get_working_objective _get_working_objective +#define has_BFP _has_BFP +#define has_XLI _has_XLI +#define is_add_rowmode _is_add_rowmode +#define is_anti_degen _is_anti_degen +#define is_binary _is_binary +#define is_break_at_first _is_break_at_first +#define is_constr_type _is_constr_type +#define is_debug _is_debug +#define is_feasible _is_feasible +#define is_unbounded _is_unbounded +#define is_infinite _is_infinite +#define is_int _is_int +#define is_integerscaling _is_integerscaling +#define is_lag_trace _is_lag_trace +#define is_maxim _is_maxim +#define is_nativeBFP _is_nativeBFP +#define is_nativeXLI _is_nativeXLI +#define is_negative _is_negative +#define is_piv_mode _is_piv_mode +#define is_piv_rule _is_piv_rule +#define is_presolve _is_presolve +#define is_scalemode _is_scalemode +#define is_scaletype _is_scaletype +#define is_semicont _is_semicont +#define is_SOS_var _is_SOS_var +#define is_trace _is_trace +#define lp_solve_version _lp_solve_version +#define make_lp _make_lp +#define print_constraints _print_constraints +#define print_debugdump _print_debugdump +#define print_duals _print_duals +#define print_lp _print_lp +#define print_objective _print_objective +#define print_scales _print_scales +#define print_solution _print_solution +#define print_str _print_str +#define print_tableau _print_tableau +#define put_abortfunc _put_abortfunc +#define put_bb_nodefunc _put_bb_nodefunc +#define put_bb_branchfunc _put_bb_branchfunc +#define put_logfunc _put_logfunc +#define put_msgfunc _put_msgfunc +#define read_LPhandle _read_LPhandle +#define read_MPShandle _read_MPShandle +#define read_XLI _read_XLI +#define read_params _read_params +#define read_basis _read_basis +#define reset_basis _reset_basis +#define reset_params _reset_params +#define resize_lp _resize_lp +#define set_add_rowmode _set_add_rowmode +#define set_anti_degen _set_anti_degen +#define set_basisvar _set_basisvar +#define set_basis _set_basis +#define set_basiscrash _set_basiscrash +#define set_bb_depthlimit _set_bb_depthlimit +#define set_bb_floorfirst _set_bb_floorfirst +#define set_bb_rule _set_bb_rule +#define set_BFP _set_BFP +#define set_binary _set_binary +#define set_bounds _set_bounds +#define set_bounds_tighter _set_bounds_tighter +#define set_break_at_first _set_break_at_first +#define set_break_at_value _set_break_at_value +#define set_column _set_column +#define set_columnex _set_columnex +#define set_col_name _set_col_name +#define set_constr_type _set_constr_type +#define set_debug _set_debug +#define set_epsb _set_epsb +#define set_epsd _set_epsd +#define set_epsel _set_epsel +#define set_epsint _set_epsint +#define set_epslevel _set_epslevel +#define set_epsperturb _set_epsperturb +#define set_epspivot _set_epspivot +#define set_unbounded _set_unbounded +#define set_improve _set_improve +#define set_infinite _set_infinite +#define set_int _set_int +#define set_lag_trace _set_lag_trace +#define set_lowbo _set_lowbo +#define set_lp_name _set_lp_name +#define set_mat _set_mat +#define set_maxim _set_maxim +#define set_maxpivot _set_maxpivot +#define set_minim _set_minim +#define set_mip_gap _set_mip_gap +#define set_multiprice _set_multiprice +#define set_negrange _set_negrange +#define set_obj_bound _set_obj_bound +#define set_obj_fn _set_obj_fn +#define set_obj_fnex _set_obj_fnex +#define set_obj _set_obj +#define set_outputfile _set_outputfile +#define set_outputstream _set_outputstream +#define set_partialprice _set_partialprice +#define set_pivoting _set_pivoting +#define set_preferdual _set_preferdual +#define set_presolve _set_presolve +#define set_print_sol _set_print_sol +#define set_pseudocosts _set_pseudocosts +#define set_rh _set_rh +#define set_rh_range _set_rh_range +#define set_rh_vec _set_rh_vec +#define set_row _set_row +#define set_rowex _set_rowex +#define set_row_name _set_row_name +#define set_scalelimit _set_scalelimit +#define set_scaling _set_scaling +#define set_semicont _set_semicont +#define set_sense _set_sense +#define set_simplextype _set_simplextype +#define set_solutionlimit _set_solutionlimit +#define set_timeout _set_timeout +#define set_trace _set_trace +#define set_upbo _set_upbo +#define set_var_branch _set_var_branch +#define set_var_weights _set_var_weights +#define set_verbose _set_verbose +#define set_XLI _set_XLI +#define solve _solve +#define str_add_column _str_add_column +#define str_add_constraint _str_add_constraint +#define str_add_lag_con _str_add_lag_con +#define str_set_obj_fn _str_set_obj_fn +#define str_set_rh_vec _str_set_rh_vec +#define time_elapsed _time_elapsed +#define unscale _unscale +#define write_lp _write_lp +#define write_LP _write_LP +#define write_mps _write_mps +#define write_MPS _write_MPS +#define write_freemps _write_freemps +#define write_freeMPS _write_freeMPS +#define write_XLI _write_XLI +#define write_basis _write_basis +#define write_params _write_params diff --git a/include/lp_fortify.h b/include/lp_fortify.h new file mode 100644 index 0000000..2acb704 --- /dev/null +++ b/include/lp_fortify.h @@ -0,0 +1,5 @@ +#ifdef FORTIFY + +#include "fortify.h" + +#endif diff --git a/include/lp_lib.h b/include/lp_lib.h new file mode 100644 index 0000000..1add5af --- /dev/null +++ b/include/lp_lib.h @@ -0,0 +1,2266 @@ + +#ifndef HEADER_lp_lib +#define HEADER_lp_lib + +/* -------------------------------------------------------------------------- + + This is the main library header file for the lp_solve v5.0 release + + Starting at version 3.0, LP_Solve is released under the LGPL license. + For full information, see the enclosed file LGPL.txt. + + Original developer: Michel Berkelaar - michel@ics.ele.tue.nl + Most changes 1.5-2.0: Jeroen Dirks - jeroend@tor.numetrix.com + Changes 3.2-4.0: Kjell Eikland - kjell.eikland@broadpark.no + (Simplex code, SOS, SC, code optimization) + Peter Notebaert - lpsolve@peno.be + (Sensitivity analysis, documentation) + Changes 5.0+: Kjell Eikland - kjell.eikland@broadpark.no + (BFP, XLI, simplex, B&B, code modularization) + Peter Notebaert - lpsolve@peno.be + (Sensitivity analysis, New lp parser, LINDO (XLI) + parser, VB/.NET interface, documentation) + + Release notes: + + Version 4.0 enhances version 3.2 in terms of internal program/simplex + architecture, call level interfaces, data layout, features and contains + several bug fixes. There is now complete support for semi-continuous + variables and SOS constructions. In the process, a complete API + was added. The MPS parser has been amended to support this. + Sensitivity analysis and variouse bug fixes was provided by Peter + Notebaert in 4.0 sub-releases. Peter also wrote a complete + documentation of the API and contributed a VB interface, both of which + significantly enhanced the accessibility of lp_solve. + + Version 5.0 is a major rewrite and code cleanup. The main additions that + drove forward this cleanup were the modular inversion logic with optimal + column ordering, addition of primal phase 1 and dual phase 2 logic for + full flexibility in the selection of primal and dual simplex modes, + DEVEX and steepest edge pivot selection, along with dynamic cycling + detection and prevention. This cleanup made it possible to harmonize the + internal rounding principles, contributing to increased numerical stability. + + Version 5.1 rearranges the matrix storage model by enabling both legacy + element record-based storage and split vector storage. In addition the + lprec structure is optimized and additional routines are added, mainly for + sparse vector additions and enhanced XLI functionality. Support for XML- + based models was added on the basis of the LPFML schema via xli_LPFML. + + Version 5.2 removes the objective function from the constraint matrix, + adds a number of presolve options and speed them up. Degeneracy handling + is significantly improved. Support for XLI_ZIMPL was added. + Multiple and partial pricing has been enhanced and activated. + + -------------------------------------------------------------------------- */ +/* Define user program feature option switches */ +/* ------------------------------------------------------------------------- */ + +#if !defined _WINDOWS && !defined _WIN32 && !defined WIN32 +# define _isnan(x) FALSE +#endif + +/* Utility/system settings */ +/* ------------------------------------------------------------------------- */ +/*#define INTEGERTIME */ /* Set use of lower-resolution timer */ + + +/* New v5.0+ simplex/optimization features and settings */ +/* ------------------------------------------------------------------------- */ +/*#define NoRowScaleOF */ /* Optionally skip row-scaling of the OF */ +#define DoMatrixRounding /* Round A matrix elements to precision */ +#define DoBorderRounding /* Round RHS, bounds and ranges to precision */ +#define Phase1EliminateRedundant /* Remove rows of redundant artificials */ +#define FixViolatedOptimal +#define ImproveSolutionPrecision /* Round optimal solution values */ +/*#define IncreasePivotOnReducedAccuracy */ /* Increase epspivot on instability */ +/*#define FixInaccurateDualMinit */ /* Reinvert on inaccuracy in dual minits */ +/*#define EnforcePositiveTheta */ /* Ensure that the theta range is valid */ +#define ResetMinitOnReinvert +/*#define UsePrimalReducedCostUpdate */ /* Not tested */ +/*#define UseDualReducedCostUpdate */ /* Seems Ok, but slower than expected */ +/*#ifdef UseLegacyExtrad */ /* Use v3.2- style Extrad method */ +#define UseMilpExpandedRCF /* Non-ints in reduced cost bound tightening */ +/*#define UseMilpSlacksRCF */ /* Slacks in reduced cost bound tightening (degen + prone); requires !SlackInitMinusInf */ +#define LegacySlackDefinition /* Slack as the "value of the constraint" */ + + +/* Development features (change at own risk) */ +/* ------------------------------------------------------------------------- */ +/*#define MIPboundWithOF */ /* Enable to detect OF constraint for use during B&B */ +/*#define SlackInitMinusInf */ /* Slacks have 0 LB if this is not defined */ +#define FULLYBOUNDEDSIMPLEX FALSE /* WARNING: Activate at your own risk! */ + + +/* Specify use of the basic linear algebra subroutine library */ +/* ------------------------------------------------------------------------- */ +#define libBLAS 2 /* 0: No, 1: Internal, 2: External */ +#define libnameBLAS "myBLAS" + + +/* Active inverse logic (default is optimized original etaPFI) */ +/* ------------------------------------------------------------------------- */ +#if !defined LoadInverseLib +# define LoadInverseLib TRUE /* Enable alternate inverse libraries */ +#endif +/*#define ExcludeNativeInverse */ /* Disable INVERSE_ACTIVE inverse engine */ + +#define DEF_OBJINBASIS TRUE /* Additional rows inserted at the top (1 => OF) */ + +#define INVERSE_NONE -1 +#define INVERSE_LEGACY 0 +#define INVERSE_ETAPFI 1 +#define INVERSE_LUMOD 2 +#define INVERSE_LUSOL 3 +#define INVERSE_GLPKLU 4 + +#ifndef RoleIsExternalInvEngine /* Defined in inverse DLL drivers */ + #ifdef ExcludeNativeInverse + #define INVERSE_ACTIVE INVERSE_NONE /* Disable native engine */ + #else + #define INVERSE_ACTIVE INVERSE_LEGACY /* User or DLL-selected */ + #endif +#endif + + +/* Active external language interface logic (default is none) */ +/* ------------------------------------------------------------------------- */ +#if !defined LoadLanguageLib +# define LoadLanguageLib TRUE /* Enable alternate language libraries */ +#endif +#define ExcludeNativeLanguage /* Disable LANGUAGE_ACTIVE XLI */ + +#define LANGUAGE_NONE -1 +#define LANGUAGE_LEGACYLP 0 +#define LANGUAGE_CPLEXLP 1 +#define LANGUAGE_MPSX 2 +#define LANGUAGE_LPFML 3 +#define LANGUAGE_MATHPROG 4 +#define LANGUAGE_AMPL 5 +#define LANGUAGE_GAMS 6 +#define LANGUAGE_ZIMPL 7 +#define LANGUAGE_S 8 +#define LANGUAGE_R 9 +#define LANGUAGE_MATLAB 10 +#define LANGUAGE_OMATRIX 11 +#define LANGUAGE_SCILAB 12 +#define LANGUAGE_OCTAVE 13 +#define LANGUAGE_EMPS 14 + +#ifndef RoleIsExternalLanguageEngine /* Defined in XLI driver libraries */ + #ifdef ExcludeNativeLanguage + #define LANGUAGE_ACTIVE LANGUAGE_NONE /* Disable native engine */ + #else + #define LANGUAGE_ACTIVE LANGUAGE_CPLEXLP /* User or DLL-selected */ + #endif +#endif + + +/* Default parameters and tolerances */ +/* ------------------------------------------------------------------------- */ +#define OriginalPARAM 0 +#define ProductionPARAM 1 +#define ChvatalPARAM 2 +#define LoosePARAM 3 +#if 1 + #define ActivePARAM ProductionPARAM +#else + #define ActivePARAM LoosePARAM +#endif + + +/* Miscellaneous settings */ +/* ------------------------------------------------------------------------- */ +#ifndef Paranoia + #ifdef _DEBUG + #define Paranoia + #endif +#endif + + +/* Program version data */ +/* ------------------------------------------------------------------------- */ +#define MAJORVERSION 5 +#define MINORVERSION 5 +#define RELEASE 0 +#define BUILD 7 +#define BFPVERSION 12 /* Checked against bfp_compatible() */ +#define XLIVERSION 12 /* Checked against xli_compatible() */ +/* Note that both BFPVERSION and XLIVERSION typically have to be incremented + in the case that the lprec structure changes. */ + + +/* Include/header files */ +/* ------------------------------------------------------------------------- */ +#include +#include +#include +#include +#include + +#include "lp_types.h" +#include "lp_utils.h" + +#if (LoadInverseLib == TRUE) || (LoadLanguageLib == TRUE) + #ifdef WIN32 + #include + #else + #include + #endif +#endif + +#ifndef BFP_CALLMODEL + #ifdef WIN32 + #define BFP_CALLMODEL __stdcall /* "Standard" call model */ + #else + #define BFP_CALLMODEL + #endif +#endif +#ifndef XLI_CALLMODEL + #define XLI_CALLMODEL BFP_CALLMODEL +#endif + +#define REGISTER register /* Speed up certain operations */ + + +/* Definition of program constrants */ +/* ------------------------------------------------------------------------- */ +#define SIMPLEX_UNDEFINED 0 +#define SIMPLEX_Phase1_PRIMAL 1 +#define SIMPLEX_Phase1_DUAL 2 +#define SIMPLEX_Phase2_PRIMAL 4 +#define SIMPLEX_Phase2_DUAL 8 +#define SIMPLEX_DYNAMIC 16 +#define SIMPLEX_AUTODUALIZE 32 + +#define SIMPLEX_PRIMAL_PRIMAL (SIMPLEX_Phase1_PRIMAL + SIMPLEX_Phase2_PRIMAL) +#define SIMPLEX_DUAL_PRIMAL (SIMPLEX_Phase1_DUAL + SIMPLEX_Phase2_PRIMAL) +#define SIMPLEX_PRIMAL_DUAL (SIMPLEX_Phase1_PRIMAL + SIMPLEX_Phase2_DUAL) +#define SIMPLEX_DUAL_DUAL (SIMPLEX_Phase1_DUAL + SIMPLEX_Phase2_DUAL) +#define SIMPLEX_DEFAULT (SIMPLEX_DUAL_PRIMAL) + +/* Variable codes (internal) */ +#define ISREAL 0 +#define ISINTEGER 1 +#define ISSEMI 2 +#define ISSOS 4 +#define ISSOSTEMPINT 8 +#define ISGUB 16 + +/* Presolve defines */ +#define PRESOLVE_NONE 0 +#define PRESOLVE_ROWS 1 +#define PRESOLVE_COLS 2 +#define PRESOLVE_LINDEP 4 +#define PRESOLVE_AGGREGATE 8 /* Not implemented */ +#define PRESOLVE_SPARSER 16 /* Not implemented */ +#define PRESOLVE_SOS 32 +#define PRESOLVE_REDUCEMIP 64 +#define PRESOLVE_KNAPSACK 128 /* Implementation not tested completely */ +#define PRESOLVE_ELIMEQ2 256 +#define PRESOLVE_IMPLIEDFREE 512 +#define PRESOLVE_REDUCEGCD 1024 +#define PRESOLVE_PROBEFIX 2048 +#define PRESOLVE_PROBEREDUCE 4096 +#define PRESOLVE_ROWDOMINATE 8192 +#define PRESOLVE_COLDOMINATE 16384 /* Reduced functionality, should be expanded */ +#define PRESOLVE_MERGEROWS 32768 +#define PRESOLVE_IMPLIEDSLK 65536 +#define PRESOLVE_COLFIXDUAL 131072 +#define PRESOLVE_BOUNDS 262144 +#define PRESOLVE_LASTMASKMODE (PRESOLVE_DUALS - 1) +#define PRESOLVE_DUALS 524288 +#define PRESOLVE_SENSDUALS 1048576 + +/* Basis crash options */ +#define CRASH_NONE 0 +#define CRASH_NONBASICBOUNDS 1 +#define CRASH_MOSTFEASIBLE 2 +#define CRASH_LEASTDEGENERATE 3 + +/* Solution recomputation options (internal) */ +#define INITSOL_SHIFTZERO 0 +#define INITSOL_USEZERO 1 +#define INITSOL_ORIGINAL 2 + +/* Strategy codes to avoid or recover from degenerate pivots, + infeasibility or numeric errors via randomized bound relaxation */ +#define ANTIDEGEN_NONE 0 +#define ANTIDEGEN_FIXEDVARS 1 +#define ANTIDEGEN_COLUMNCHECK 2 +#define ANTIDEGEN_STALLING 4 +#define ANTIDEGEN_NUMFAILURE 8 +#define ANTIDEGEN_LOSTFEAS 16 +#define ANTIDEGEN_INFEASIBLE 32 +#define ANTIDEGEN_DYNAMIC 64 +#define ANTIDEGEN_DURINGBB 128 +#define ANTIDEGEN_RHSPERTURB 256 +#define ANTIDEGEN_BOUNDFLIP 512 +#define ANTIDEGEN_DEFAULT (ANTIDEGEN_FIXEDVARS | ANTIDEGEN_STALLING /* | ANTIDEGEN_INFEASIBLE */) + +/* REPORT defines */ +#define NEUTRAL 0 +#define CRITICAL 1 +#define SEVERE 2 +#define IMPORTANT 3 +#define NORMAL 4 +#define DETAILED 5 +#define FULL 6 + +/* MESSAGE defines */ +#define MSG_NONE 0 +#define MSG_PRESOLVE 1 +#define MSG_ITERATION 2 +#define MSG_INVERT 4 +#define MSG_LPFEASIBLE 8 +#define MSG_LPOPTIMAL 16 +#define MSG_LPEQUAL 32 +#define MSG_LPBETTER 64 +#define MSG_MILPFEASIBLE 128 +#define MSG_MILPEQUAL 256 +#define MSG_MILPBETTER 512 +#define MSG_MILPSTRATEGY 1024 +#define MSG_MILPOPTIMAL 2048 +#define MSG_PERFORMANCE 4096 +#define MSG_INITPSEUDOCOST 8192 + +/* MPS defines (internal) */ +#define MPSUNDEF -4 +#define MPSNAME -3 +#define MPSOBJSENSE -2 +#define MPSOBJNAME -1 +#define MPSROWS 0 +#define MPSCOLUMNS 1 +#define MPSRHS 2 +#define MPSBOUNDS 3 +#define MPSRANGES 4 +#define MPSSOS 5 + +#define MPSVARMASK "%-8s" +#define MPSVALUEMASK "%12g" + +/* Constraint type codes (internal) */ +#define ROWTYPE_EMPTY 0 +#define ROWTYPE_LE 1 +#define ROWTYPE_GE 2 +#define ROWTYPE_EQ 3 +#define ROWTYPE_CONSTRAINT ROWTYPE_EQ /* This is the mask for modes */ +#define ROWTYPE_OF 4 +#define ROWTYPE_INACTIVE 8 +#define ROWTYPE_RELAX 16 +#define ROWTYPE_GUB 32 +#define ROWTYPE_OFMAX (ROWTYPE_OF + ROWTYPE_GE) +#define ROWTYPE_OFMIN (ROWTYPE_OF + ROWTYPE_LE) +#define ROWTYPE_CHSIGN ROWTYPE_GE + +/* Public constraint codes */ +#define FR ROWTYPE_EMPTY +#define LE ROWTYPE_LE +#define GE ROWTYPE_GE +#define EQ ROWTYPE_EQ +#define OF ROWTYPE_OF + +/* MIP constraint classes */ +#define ROWCLASS_Unknown 0 /* Undefined/unknown */ +#define ROWCLASS_Objective 1 /* The objective function */ +#define ROWCLASS_GeneralREAL 2 /* General real-values constraint */ +#define ROWCLASS_GeneralMIP 3 /* General mixed integer/binary and real valued constraint */ +#define ROWCLASS_GeneralINT 4 /* General integer-only constraint */ +#define ROWCLASS_GeneralBIN 5 /* General binary-only constraint */ +#define ROWCLASS_KnapsackINT 6 /* Sum of positive integer times integer variables <= positive integer */ +#define ROWCLASS_KnapsackBIN 7 /* Sum of positive integer times binary variables <= positive integer */ +#define ROWCLASS_SetPacking 8 /* Sum of binary variables >= 1 */ +#define ROWCLASS_SetCover 9 /* Sum of binary variables <= 1 */ +#define ROWCLASS_GUB 10 /* Sum of binary variables = 1 */ +#define ROWCLASS_MAX ROWCLASS_GUB + +/* Column subsets (internal) */ +#define SCAN_USERVARS 1 +#define SCAN_SLACKVARS 2 +#define SCAN_ARTIFICIALVARS 4 +#define SCAN_PARTIALBLOCK 8 +#define USE_BASICVARS 16 +#define USE_NONBASICVARS 32 +#define SCAN_NORMALVARS (SCAN_USERVARS + SCAN_ARTIFICIALVARS) +#define SCAN_ALLVARS (SCAN_SLACKVARS + SCAN_USERVARS + SCAN_ARTIFICIALVARS) +#define USE_ALLVARS (USE_BASICVARS + USE_NONBASICVARS) +#define OMIT_FIXED 64 +#define OMIT_NONFIXED 128 + +/* Improvement defines */ +#define IMPROVE_NONE 0 +#define IMPROVE_SOLUTION 1 +#define IMPROVE_DUALFEAS 2 +#define IMPROVE_THETAGAP 4 +#define IMPROVE_BBSIMPLEX 8 +#define IMPROVE_DEFAULT (IMPROVE_DUALFEAS + IMPROVE_THETAGAP) +#define IMPROVE_INVERSE (IMPROVE_SOLUTION + IMPROVE_THETAGAP) + +/* Scaling types */ +#define SCALE_NONE 0 +#define SCALE_EXTREME 1 +#define SCALE_RANGE 2 +#define SCALE_MEAN 3 +#define SCALE_GEOMETRIC 4 +#define SCALE_FUTURE1 5 +#define SCALE_FUTURE2 6 +#define SCALE_CURTISREID 7 /* Override to Curtis-Reid "optimal" scaling */ + +/* Alternative scaling weights */ +#define SCALE_LINEAR 0 +#define SCALE_QUADRATIC 8 +#define SCALE_LOGARITHMIC 16 +#define SCALE_USERWEIGHT 31 +#define SCALE_MAXTYPE (SCALE_QUADRATIC-1) + +/* Scaling modes */ +#define SCALE_POWER2 32 /* As is or rounded to power of 2 */ +#define SCALE_EQUILIBRATE 64 /* Make sure that no scaled number is above 1 */ +#define SCALE_INTEGERS 128 /* Apply to integer columns/variables */ +#define SCALE_DYNUPDATE 256 /* Apply incrementally every solve() */ +#define SCALE_ROWSONLY 512 /* Override any scaling to only scale the rows */ +#define SCALE_COLSONLY 1024 /* Override any scaling to only scale the rows */ + +/* Standard defines for typical scaling models (no Lagrangeans) */ +#define SCALEMODEL_EQUILIBRATED (SCALE_LINEAR+SCALE_EXTREME+SCALE_INTEGERS) +#define SCALEMODEL_GEOMETRIC (SCALE_LINEAR+SCALE_GEOMETRIC+SCALE_INTEGERS) +#define SCALEMODEL_ARITHMETIC (SCALE_LINEAR+SCALE_MEAN+SCALE_INTEGERS) +#define SCALEMODEL_DYNAMIC (SCALEMODEL_GEOMETRIC+SCALE_EQUILIBRATE) +#define SCALEMODEL_CURTISREID (SCALE_CURTISREID+SCALE_INTEGERS+SCALE_POWER2) + +/* Iteration status and strategies (internal) */ +#define ITERATE_MAJORMAJOR 0 +#define ITERATE_MINORMAJOR 1 +#define ITERATE_MINORRETRY 2 + +/* Pricing methods */ +#define PRICER_FIRSTINDEX 0 +#define PRICER_DANTZIG 1 +#define PRICER_DEVEX 2 +#define PRICER_STEEPESTEDGE 3 +#define PRICER_LASTOPTION PRICER_STEEPESTEDGE + +/* Additional settings for pricers (internal) */ +#define PRICER_RANDFACT 0.1 +#define DEVEX_RESTARTLIMIT 1.0e+09 /* Reset the norms if any value exceeds this limit */ +#define DEVEX_MINVALUE 0.000 /* Minimum weight [0..1] for entering variable, consider 0.01 */ + +/* Pricing strategies */ +#define PRICE_PRIMALFALLBACK 4 /* In case of Steepest Edge, fall back to DEVEX in primal */ +#define PRICE_MULTIPLE 8 /* Enable multiple pricing (primal simplex) */ +#define PRICE_PARTIAL 16 /* Enable partial pricing */ +#define PRICE_ADAPTIVE 32 /* Temporarily use alternative strategy if cycling is detected */ +#define PRICE_HYBRID 64 /* NOT IMPLEMENTED */ +#define PRICE_RANDOMIZE 128 /* Adds a small randomization effect to the selected pricer */ +#define PRICE_AUTOPARTIAL 256 /* Detect and use data on the block structure of the model (primal) */ +#define PRICE_AUTOMULTIPLE 512 /* Automatically select multiple pricing (primal simplex) */ +#define PRICE_LOOPLEFT 1024 /* Scan entering/leaving columns left rather than right */ +#define PRICE_LOOPALTERNATE 2048 /* Scan entering/leaving columns alternatingly left/right */ +#define PRICE_HARRISTWOPASS 4096 /* Use Harris' primal pivot logic rather than the default */ +#define PRICE_FORCEFULL 8192 /* Non-user option to force full pricing */ +#define PRICE_TRUENORMINIT 16384 /* Use true norms for Devex and Steepest Edge initializations */ + +#define PRICE_STRATEGYMASK (PRICE_PRIMALFALLBACK + \ + PRICE_MULTIPLE + PRICE_PARTIAL + \ + PRICE_ADAPTIVE + PRICE_HYBRID + \ + PRICE_RANDOMIZE + PRICE_AUTOPARTIAL + PRICE_AUTOMULTIPLE + \ + PRICE_LOOPLEFT + PRICE_LOOPALTERNATE + \ + PRICE_HARRISTWOPASS + \ + PRICE_FORCEFULL + PRICE_TRUENORMINIT) + +/* B&B active variable codes (internal) */ +#define BB_REAL 0 +#define BB_INT 1 +#define BB_SC 2 +#define BB_SOS 3 +#define BB_GUB 4 + +/* B&B strategies */ +#define NODE_FIRSTSELECT 0 +#define NODE_GAPSELECT 1 +#define NODE_RANGESELECT 2 +#define NODE_FRACTIONSELECT 3 +#define NODE_PSEUDOCOSTSELECT 4 +#define NODE_PSEUDONONINTSELECT 5 /* Kjell Eikland #1 - Minimize B&B depth */ +#define NODE_PSEUDOFEASSELECT (NODE_PSEUDONONINTSELECT+NODE_WEIGHTREVERSEMODE) +#define NODE_PSEUDORATIOSELECT 6 /* Kjell Eikland #2 - Minimize a "cost/benefit" ratio */ +#define NODE_USERSELECT 7 +#define NODE_STRATEGYMASK (NODE_WEIGHTREVERSEMODE-1) /* Mask for B&B strategies */ +#define NODE_WEIGHTREVERSEMODE 8 +#define NODE_BRANCHREVERSEMODE 16 +#define NODE_GREEDYMODE 32 +#define NODE_PSEUDOCOSTMODE 64 +#define NODE_DEPTHFIRSTMODE 128 +#define NODE_RANDOMIZEMODE 256 +#define NODE_GUBMODE 512 +#define NODE_DYNAMICMODE 1024 +#define NODE_RESTARTMODE 2048 +#define NODE_BREADTHFIRSTMODE 4096 +#define NODE_AUTOORDER 8192 +#define NODE_RCOSTFIXING 16384 +#define NODE_STRONGINIT 32768 + +#define BRANCH_CEILING 0 +#define BRANCH_FLOOR 1 +#define BRANCH_AUTOMATIC 2 +#define BRANCH_DEFAULT 3 + +/* Action constants for simplex and B&B (internal) */ +#define ACTION_NONE 0 +#define ACTION_ACTIVE 1 +#define ACTION_REBASE 2 +#define ACTION_RECOMPUTE 4 +#define ACTION_REPRICE 8 +#define ACTION_REINVERT 16 +#define ACTION_TIMEDREINVERT 32 +#define ACTION_ITERATE 64 +#define ACTION_RESTART 255 + +/* Solver status values */ +#define UNKNOWNERROR -5 +#define DATAIGNORED -4 +#define NOBFP -3 +#define NOMEMORY -2 +#define NOTRUN -1 +#define OPTIMAL 0 +#define SUBOPTIMAL 1 +#define INFEASIBLE 2 +#define UNBOUNDED 3 +#define DEGENERATE 4 +#define NUMFAILURE 5 +#define USERABORT 6 +#define TIMEOUT 7 +#define RUNNING 8 +#define PRESOLVED 9 + +/* Branch & Bound and Lagrangean extra status values (internal) */ +#define PROCFAIL 10 +#define PROCBREAK 11 +#define FEASFOUND 12 +#define NOFEASFOUND 13 +#define FATHOMED 14 + +/* Status values internal to the solver (internal) */ +#define SWITCH_TO_PRIMAL 20 +#define SWITCH_TO_DUAL 21 +#define SINGULAR_BASIS 22 +#define LOSTFEAS 23 +#define MATRIXERROR 24 + +/* Objective testing options for "bb_better" (internal) */ +#define OF_RELAXED 0 +#define OF_INCUMBENT 1 +#define OF_WORKING 2 +#define OF_USERBREAK 3 +#define OF_HEURISTIC 4 +#define OF_DUALLIMIT 5 +#define OF_DELTA 8 /* Mode */ +#define OF_PROJECTED 16 /* Mode - future, not active */ + +#define OF_TEST_BT 1 +#define OF_TEST_BE 2 +#define OF_TEST_NE 3 +#define OF_TEST_WE 4 +#define OF_TEST_WT 5 +#define OF_TEST_RELGAP 8 /* Mode */ + + +/* Name list and sparse matrix storage parameters (internal) */ +#define MAT_START_SIZE 10000 +#define DELTACOLALLOC 100 +#define DELTAROWALLOC 100 +#define RESIZEFACTOR 4 /* Fractional increase in selected memory allocations */ + +/* Default solver parameters and tolerances (internal) */ +#define DEF_PARTIALBLOCKS 10 /* The default number of blocks for partial pricing */ +#define DEF_MAXRELAX 7 /* Maximum number of non-BB relaxations in MILP */ +#define DEF_MAXPIVOTRETRY 10 /* Maximum number of times to retry a div-0 situation */ +#define DEF_MAXSINGULARITIES 10 /* Maximum number of singularities in refactorization */ +#define MAX_MINITUPDATES 60 /* Maximum number of bound swaps between refactorizations + without recomputing the whole vector - contain errors */ +#define MIN_REFACTFREQUENCY 5 /* Refactorization frequency indicating an inherent + numerical instability of the basis */ +#define LAG_SINGULARLIMIT 5 /* Number of times the objective does not change + before it is assumed that the Lagrangean constraints + are non-binding, and therefore impossible to converge; + upper iteration limit is divided by this threshold */ +#define MIN_TIMEPIVOT 5.0e-02 /* Minimum time per pivot for reinversion optimization + purposes; use active monitoring only if a pivot + takes more than MINTIMEPIVOT seconds. 5.0e-2 is + roughly suitable for a 1GHz system. */ +#define MAX_STALLCOUNT 12 /* The absolute upper limit to the number of stalling or + cycling iterations before switching rule */ +#define MAX_RULESWITCH 5 /* The maximum number of times to try an alternate pricing rule + to recover from stalling; set negative for no limit. */ +#define DEF_TIMEDREFACT AUTOMATIC /* Default for timed refactorization in BFPs; + can be FALSE, TRUE or AUTOMATIC (dynamic) */ + +#define DEF_SCALINGLIMIT 5 /* The default maximum number of scaling iterations */ + +#define DEF_NEGRANGE -1.0e+06 /* Downward limit for expanded variable range before the + variable is split into positive and negative components */ +#define DEF_BB_LIMITLEVEL -50 /* Relative B&B limit to protect against very deep, + memory-consuming trees */ + +#define MAX_FRACSCALE 6 /* The maximum decimal scan range for simulated integers */ +#define RANDSCALE 100 /* Randomization scaling range */ +#define DOUBLEROUND 0.0e-02 /* Extra rounding scalar used in btran/ftran calculations; the + rationale for 0.0 is that prod_xA() uses rounding as well */ +#define DEF_EPSMACHINE 2.22e-16 /* Machine relative precision (doubles) */ +#define MIN_STABLEPIVOT 5.0 /* Minimum pivot magnitude assumed to be numerically stable */ + + +/* Precision macros */ +/* -------------------------------------------------------------------------------------- */ +#define PREC_REDUCEDCOST lp->epsvalue +#define PREC_IMPROVEGAP lp->epsdual +#define PREC_SUBSTFEASGAP lp->epsprimal +#if 1 + #define PREC_BASICSOLUTION lp->epsvalue /* Zero-rounding of RHS/basic solution vector */ +#else + #define PREC_BASICSOLUTION lp->epsmachine /* Zero-rounding of RHS/basic solution vector */ +#endif +#define LIMIT_ABS_REL 10.0 /* Limit for testing using relative metric */ + + +/* Parameters constants for short-cut setting of tolerances */ +/* -------------------------------------------------------------------------------------- */ +#define EPS_TIGHT 0 +#define EPS_MEDIUM 1 +#define EPS_LOOSE 2 +#define EPS_BAGGY 3 +#define EPS_DEFAULT EPS_TIGHT + + +#if ActivePARAM==ProductionPARAM /* PARAMETER SET FOR PRODUCTION */ +/* -------------------------------------------------------------------------------------- */ +#define DEF_INFINITE 1.0e+30 /* Limit for dynamic range */ +#define DEF_EPSVALUE 1.0e-12 /* High accuracy and feasibility preserving tolerance */ +#define DEF_EPSPRIMAL 1.0e-10 /* For rounding primal/RHS values to 0 */ +#define DEF_EPSDUAL 1.0e-09 /* For rounding reduced costs to 0 */ +#define DEF_EPSPIVOT 2.0e-07 /* Pivot reject threshold */ +#define DEF_PERTURB 1.0e-05 /* Perturbation scalar for degenerate problems; + must at least be RANDSCALE greater than EPSPRIMAL */ +#define DEF_EPSSOLUTION 1.0e-05 /* Margin of error for solution bounds */ +#define DEF_EPSINT 1.0e-07 /* Accuracy for considering a float value as integer */ + +#elif ActivePARAM==OriginalPARAM /* PARAMETER SET FOR LEGACY VERSIONS */ +/* -------------------------------------------------------------------------------------- */ +#define DEF_INFINITE 1.0e+24 /* Limit for dynamic range */ +#define DEF_EPSVALUE 1.0e-08 /* High accuracy and feasibility preserving tolerance */ +#define DEF_EPSPRIMAL 5.01e-07 /* For rounding primal/RHS values to 0, infeasibility */ +#define DEF_EPSDUAL 1.0e-06 /* For rounding reduced costs to 0 */ +#define DEF_EPSPIVOT 1.0e-04 /* Pivot reject threshold */ +#define DEF_PERTURB 1.0e-05 /* Perturbation scalar for degenerate problems; + must at least be RANDSCALE greater than EPSPRIMAL */ +#define DEF_EPSSOLUTION 1.0e-02 /* Margin of error for solution bounds */ +#define DEF_EPSINT 1.0e-03 /* Accuracy for considering a float value as integer */ + +#elif ActivePARAM==ChvatalPARAM /* PARAMETER SET EXAMPLES FROM Vacek Chvatal */ +/* -------------------------------------------------------------------------------------- */ +#define DEF_INFINITE 1.0e+30 /* Limit for dynamic range */ +#define DEF_EPSVALUE 1.0e-10 /* High accuracy and feasibility preserving tolerance */ +#define DEF_EPSPRIMAL 10e-07 /* For rounding primal/RHS values to 0 */ +#define DEF_EPSDUAL 10e-05 /* For rounding reduced costs to 0 */ +#define DEF_EPSPIVOT 10e-05 /* Pivot reject threshold */ +#define DEF_PERTURB 10e-03 /* Perturbation scalar for degenerate problems; + must at least be RANDSCALE greater than EPSPRIMAL */ +#define DEF_EPSSOLUTION 1.0e-05 /* Margin of error for solution bounds */ +#define DEF_EPSINT 5.0e-03 /* Accuracy for considering a float value as integer */ + +#elif ActivePARAM==LoosePARAM /* PARAMETER SET FOR LOOSE TOLERANCES */ +/* -------------------------------------------------------------------------------------- */ +#define DEF_INFINITE 1.0e+30 /* Limit for dynamic range */ +#define DEF_EPSVALUE 1.0e-10 /* High accuracy and feasibility preserving tolerance */ +#define DEF_EPSPRIMAL 5.01e-08 /* For rounding primal/RHS values to 0 */ +#define DEF_EPSDUAL 1.0e-07 /* For rounding reduced costs to 0 */ +#define DEF_EPSPIVOT 1.0e-05 /* Pivot reject threshold */ +#define DEF_PERTURB 1.0e-05 /* Perturbation scalar for degenerate problems; + must at least be RANDSCALE greater than EPSPRIMAL */ +#define DEF_EPSSOLUTION 1.0e-05 /* Margin of error for solution bounds */ +#define DEF_EPSINT 1.0e-04 /* Accuracy for considering a float value as integer */ + +#endif + + +#define DEF_MIP_GAP 1.0e-11 /* The default absolute and relative MIP gap */ +#define SCALEDINTFIXRANGE 1.6 /* Epsilon range multiplier < 2 for collapsing bounds to fix */ + +#define MIN_SCALAR 1.0e-10 /* Smallest allowed scaling adjustment */ +#define MAX_SCALAR 1.0e+10 /* Largest allowed scaling adjustment */ +#define DEF_SCALINGEPS 1.0e-02 /* Relative scaling convergence criterion for auto_scale */ + +#define DEF_LAGACCEPT 1.0e-03 /* Default Lagrangean convergence acceptance criterion */ +#define DEF_LAGCONTRACT 0.90 /* The contraction parameter for Lagrangean iterations */ +#define DEF_LAGMAXITERATIONS 100 /* The maximum number of Lagrangean iterations */ + +#define DEF_PSEUDOCOSTUPDATES 7 /* The default number of times pseudo-costs are recalculated; + experiments indicate that costs tend to stabilize */ +#define DEF_PSEUDOCOSTRESTART 0.15 /* The fraction of price updates required for B&B restart + when the mode is NODE_RESTARTMODE */ +#define DEF_MAXPRESOLVELOOPS 0 /* Upper limit to the number of loops during presolve, + <= 0 for no limit. */ + + +/* Hashing prototypes and function headers */ +/* ------------------------------------------------------------------------- */ +#include "lp_Hash.h" + + +/* Sparse matrix prototypes */ +/* ------------------------------------------------------------------------- */ +#include "lp_matrix.h" + + +/* Basis storage (mainly for B&B) */ +typedef struct _basisrec +{ + int level; + int *var_basic; + MYBOOL *is_basic; + MYBOOL *is_lower; + int pivots; + struct _basisrec *previous; +} basisrec; + +/* Presolve undo data storage */ +typedef struct _presolveundorec +{ + lprec *lp; + int orig_rows; + int orig_columns; + int orig_sum; + int *var_to_orig; /* sum_alloc+1 : Mapping of variables from solution to + best_solution to account for removed variables and + rows during presolve; a non-positive value indicates + that the constraint or variable was removed */ + int *orig_to_var; /* sum_alloc+1 : Mapping from original variable index to + current / working index number */ + REAL *fixed_rhs; /* rows_alloc+1 : Storage of values of presolved fixed colums */ + REAL *fixed_obj; /* columns_alloc+1: Storage of values of presolved fixed rows */ + DeltaVrec *deletedA; /* A matrix of eliminated data from matA */ + DeltaVrec *primalundo; /* Affine translation vectors for eliminated primal variables */ + DeltaVrec *dualundo; /* Affine translation vectors for eliminated dual variables */ + MYBOOL OFcolsdeleted; +} presolveundorec; + +/* Pseudo-cost arrays used during B&B */ +typedef struct _BBPSrec +{ + lprec *lp; + int pseodotype; + int updatelimit; + int updatesfinished; + REAL restartlimit; + MATitem *UPcost; + MATitem *LOcost; + struct _BBPSrec *secondary; +} BBPSrec; + +#include "lp_mipbb.h" + + +/* Partial pricing block data */ +typedef struct _partialrec { + lprec *lp; + int blockcount; /* ## The number of logical blocks or stages in the model */ + int blocknow; /* The currently active block */ + int *blockend; /* Array of column indeces giving the start of each block */ + int *blockpos; /* Array of column indeces giving the start scan position */ + MYBOOL isrow; +} partialrec; + + +/* Specially Ordered Sets (SOS) prototypes and settings */ +/* ------------------------------------------------------------------------- */ +/* SOS storage structure (LINEARSEARCH is typically in the 0-10 range) */ +#ifndef LINEARSEARCH +#define LINEARSEARCH 0 +#endif + +#include "lp_SOS.h" + + +/* Prototypes for user call-back functions */ +/* ------------------------------------------------------------------------- */ +typedef int (__WINAPI lphandle_intfunc)(lprec *lp, void *userhandle); +typedef void (__WINAPI lphandlestr_func)(lprec *lp, void *userhandle, char *buf); +typedef void (__WINAPI lphandleint_func)(lprec *lp, void *userhandle, int message); +typedef int (__WINAPI lphandleint_intfunc)(lprec *lp, void *userhandle, int message); + + +/* API typedef definitions */ +/* ------------------------------------------------------------------------- */ +typedef MYBOOL (__WINAPI add_column_func)(lprec *lp, REAL *column); +typedef MYBOOL (__WINAPI add_columnex_func)(lprec *lp, int count, REAL *column, int *rowno); +typedef MYBOOL (__WINAPI add_constraint_func)(lprec *lp, REAL *row, int constr_type, REAL rh); +typedef MYBOOL (__WINAPI add_constraintex_func)(lprec *lp, int count, REAL *row, int *colno, int constr_type, REAL rh); +typedef MYBOOL (__WINAPI add_lag_con_func)(lprec *lp, REAL *row, int con_type, REAL rhs); +typedef int (__WINAPI add_SOS_func)(lprec *lp, char *name, int sostype, int priority, int count, int *sosvars, REAL *weights); +typedef int (__WINAPI column_in_lp_func)(lprec *lp, REAL *column); +typedef lprec * (__WINAPI copy_lp_func)(lprec *lp); +typedef void (__WINAPI default_basis_func)(lprec *lp); +typedef MYBOOL (__WINAPI del_column_func)(lprec *lp, int colnr); +typedef MYBOOL (__WINAPI del_constraint_func)(lprec *lp, int rownr); +typedef void (__WINAPI delete_lp_func)(lprec *lp); +typedef MYBOOL (__WINAPI dualize_lp_func)(lprec *lp); +typedef void (__WINAPI free_lp_func)(lprec **plp); +typedef int (__WINAPI get_anti_degen_func)(lprec *lp); +typedef MYBOOL (__WINAPI get_basis_func)(lprec *lp, int *bascolumn, MYBOOL nonbasic); +typedef int (__WINAPI get_basiscrash_func)(lprec *lp); +typedef int (__WINAPI get_bb_depthlimit_func)(lprec *lp); +typedef int (__WINAPI get_bb_floorfirst_func)(lprec *lp); +typedef int (__WINAPI get_bb_rule_func)(lprec *lp); +typedef MYBOOL (__WINAPI get_bounds_tighter_func)(lprec *lp); +typedef REAL (__WINAPI get_break_at_value_func)(lprec *lp); +typedef char * (__WINAPI get_col_name_func)(lprec *lp, int colnr); +typedef MYBOOL (__WINAPI get_column_func)(lprec *lp, int colnr, REAL *column); +typedef int (__WINAPI get_columnex_func)(lprec *lp, int colnr, REAL *column, int *nzrow); +typedef int (__WINAPI get_constr_type_func)(lprec *lp, int rownr); +typedef REAL (__WINAPI get_constr_value_func)(lprec *lp, int rownr, int count, REAL *primsolution, int *nzindex); +typedef MYBOOL (__WINAPI get_constraints_func)(lprec *lp, REAL *constr); +typedef MYBOOL (__WINAPI get_dual_solution_func)(lprec *lp, REAL *rc); +typedef REAL (__WINAPI get_epsb_func)(lprec *lp); +typedef REAL (__WINAPI get_epsd_func)(lprec *lp); +typedef REAL (__WINAPI get_epsel_func)(lprec *lp); +typedef REAL (__WINAPI get_epsint_func)(lprec *lp); +typedef REAL (__WINAPI get_epsperturb_func)(lprec *lp); +typedef REAL (__WINAPI get_epspivot_func)(lprec *lp); +typedef int (__WINAPI get_improve_func)(lprec *lp); +typedef REAL (__WINAPI get_infinite_func)(lprec *lp); +typedef MYBOOL (__WINAPI get_lambda_func)(lprec *lp, REAL *lambda); +typedef REAL (__WINAPI get_lowbo_func)(lprec *lp, int colnr); +typedef int (__WINAPI get_lp_index_func)(lprec *lp, int orig_index); +typedef char * (__WINAPI get_lp_name_func)(lprec *lp); +typedef int (__WINAPI get_Lrows_func)(lprec *lp); +typedef REAL (__WINAPI get_mat_func)(lprec *lp, int rownr, int colnr); +typedef REAL (__WINAPI get_mat_byindex_func)(lprec *lp, int matindex, MYBOOL isrow, MYBOOL adjustsign); +typedef int (__WINAPI get_max_level_func)(lprec *lp); +typedef int (__WINAPI get_maxpivot_func)(lprec *lp); +typedef REAL (__WINAPI get_mip_gap_func)(lprec *lp, MYBOOL absolute); +typedef int (__WINAPI get_multiprice_func)(lprec *lp, MYBOOL getabssize); +typedef MYBOOL (__WINAPI is_use_names_func)(lprec *lp, MYBOOL isrow); +typedef void (__WINAPI set_use_names_func)(lprec *lp, MYBOOL isrow, MYBOOL use_names); +typedef int (__WINAPI get_nameindex_func)(lprec *lp, char *varname, MYBOOL isrow); +typedef int (__WINAPI get_Ncolumns_func)(lprec *lp); +typedef REAL (__WINAPI get_negrange_func)(lprec *lp); +typedef int (__WINAPI get_nz_func)(lprec *lp); +typedef int (__WINAPI get_Norig_columns_func)(lprec *lp); +typedef int (__WINAPI get_Norig_rows_func)(lprec *lp); +typedef int (__WINAPI get_Nrows_func)(lprec *lp); +typedef REAL (__WINAPI get_obj_bound_func)(lprec *lp); +typedef REAL (__WINAPI get_objective_func)(lprec *lp); +typedef int (__WINAPI get_orig_index_func)(lprec *lp, int lp_index); +typedef char * (__WINAPI get_origcol_name_func)(lprec *lp, int colnr); +typedef char * (__WINAPI get_origrow_name_func)(lprec *lp, int rownr); +typedef void (__WINAPI get_partialprice_func)(lprec *lp, int *blockcount, int *blockstart, MYBOOL isrow); +typedef int (__WINAPI get_pivoting_func)(lprec *lp); +typedef int (__WINAPI get_presolve_func)(lprec *lp); +typedef int (__WINAPI get_presolveloops_func)(lprec *lp); +typedef MYBOOL (__WINAPI get_primal_solution_func)(lprec *lp, REAL *pv); +typedef int (__WINAPI get_print_sol_func)(lprec *lp); +typedef MYBOOL (__WINAPI get_pseudocosts_func)(lprec *lp, REAL *clower, REAL *cupper, int *updatelimit); +typedef MYBOOL (__WINAPI get_ptr_constraints_func)(lprec *lp, REAL **constr); +typedef MYBOOL (__WINAPI get_ptr_dual_solution_func)(lprec *lp, REAL **rc); +typedef MYBOOL (__WINAPI get_ptr_lambda_func)(lprec *lp, REAL **lambda); +typedef MYBOOL (__WINAPI get_ptr_primal_solution_func)(lprec *lp, REAL **pv); +typedef MYBOOL (__WINAPI get_ptr_sensitivity_obj_func)(lprec *lp, REAL **objfrom, REAL **objtill); +typedef MYBOOL (__WINAPI get_ptr_sensitivity_objex_func)(lprec *lp, REAL **objfrom, REAL **objtill, REAL **objfromvalue, REAL **objtillvalue); +typedef MYBOOL (__WINAPI get_ptr_sensitivity_rhs_func)(lprec *lp, REAL **duals, REAL **dualsfrom, REAL **dualstill); +typedef MYBOOL (__WINAPI get_ptr_variables_func)(lprec *lp, REAL **var); +typedef REAL (__WINAPI get_rh_func)(lprec *lp, int rownr); +typedef REAL (__WINAPI get_rh_range_func)(lprec *lp, int rownr); +typedef int (__WINAPI get_rowex_func)(lprec *lp, int rownr, REAL *row, int *colno); +typedef MYBOOL (__WINAPI get_row_func)(lprec *lp, int rownr, REAL *row); +typedef char * (__WINAPI get_row_name_func)(lprec *lp, int rownr); +typedef REAL (__WINAPI get_scalelimit_func)(lprec *lp); +typedef int (__WINAPI get_scaling_func)(lprec *lp); +typedef MYBOOL (__WINAPI get_sensitivity_obj_func)(lprec *lp, REAL *objfrom, REAL *objtill); +typedef MYBOOL (__WINAPI get_sensitivity_objex_func)(lprec *lp, REAL *objfrom, REAL *objtill, REAL *objfromvalue, REAL *objtillvalue); +typedef MYBOOL (__WINAPI get_sensitivity_rhs_func)(lprec *lp, REAL *duals, REAL *dualsfrom, REAL *dualstill); +typedef int (__WINAPI get_simplextype_func)(lprec *lp); +typedef int (__WINAPI get_solutioncount_func)(lprec *lp); +typedef int (__WINAPI get_solutionlimit_func)(lprec *lp); +typedef int (__WINAPI get_status_func)(lprec *lp); +typedef char * (__WINAPI get_statustext_func)(lprec *lp, int statuscode); +typedef long (__WINAPI get_timeout_func)(lprec *lp); +typedef COUNTER (__WINAPI get_total_iter_func)(lprec *lp); +typedef COUNTER (__WINAPI get_total_nodes_func)(lprec *lp); +typedef REAL (__WINAPI get_upbo_func)(lprec *lp, int colnr); +typedef int (__WINAPI get_var_branch_func)(lprec *lp, int colnr); +typedef REAL (__WINAPI get_var_dualresult_func)(lprec *lp, int index); +typedef REAL (__WINAPI get_var_primalresult_func)(lprec *lp, int index); +typedef int (__WINAPI get_var_priority_func)(lprec *lp, int colnr); +typedef MYBOOL (__WINAPI get_variables_func)(lprec *lp, REAL *var); +typedef int (__WINAPI get_verbose_func)(lprec *lp); +typedef REAL (__WINAPI get_working_objective_func)(lprec *lp); +typedef MYBOOL (__WINAPI has_BFP_func)(lprec *lp); +typedef MYBOOL (__WINAPI has_XLI_func)(lprec *lp); +typedef MYBOOL (__WINAPI is_add_rowmode_func)(lprec *lp); +typedef MYBOOL (__WINAPI is_anti_degen_func)(lprec *lp, int testmask); +typedef MYBOOL (__WINAPI is_binary_func)(lprec *lp, int colnr); +typedef MYBOOL (__WINAPI is_break_at_first_func)(lprec *lp); +typedef MYBOOL (__WINAPI is_constr_type_func)(lprec *lp, int rownr, int mask); +typedef MYBOOL (__WINAPI is_debug_func)(lprec *lp); +typedef MYBOOL (__WINAPI is_feasible_func)(lprec *lp, REAL *values, REAL threshold); +typedef MYBOOL (__WINAPI is_unbounded_func)(lprec *lp, int colnr); +typedef MYBOOL (__WINAPI is_infinite_func)(lprec *lp, REAL value); +typedef MYBOOL (__WINAPI is_int_func)(lprec *lp, int column); +typedef MYBOOL (__WINAPI is_integerscaling_func)(lprec *lp); +typedef MYBOOL (__WINAPI is_lag_trace_func)(lprec *lp); +typedef MYBOOL (__WINAPI is_maxim_func)(lprec *lp); +typedef MYBOOL (__WINAPI is_nativeBFP_func)(lprec *lp); +typedef MYBOOL (__WINAPI is_nativeXLI_func)(lprec *lp); +typedef MYBOOL (__WINAPI is_negative_func)(lprec *lp, int colnr); +typedef MYBOOL (__WINAPI is_obj_in_basis_func)(lprec *lp); +typedef MYBOOL (__WINAPI is_piv_mode_func)(lprec *lp, int testmask); +typedef MYBOOL (__WINAPI is_piv_rule_func)(lprec *lp, int rule); +typedef MYBOOL (__WINAPI is_presolve_func)(lprec *lp, int testmask); +typedef MYBOOL (__WINAPI is_scalemode_func)(lprec *lp, int testmask); +typedef MYBOOL (__WINAPI is_scaletype_func)(lprec *lp, int scaletype); +typedef MYBOOL (__WINAPI is_semicont_func)(lprec *lp, int colnr); +typedef MYBOOL (__WINAPI is_SOS_var_func)(lprec *lp, int colnr); +typedef MYBOOL (__WINAPI is_trace_func)(lprec *lp); +typedef void (__WINAPI lp_solve_version_func)(int *majorversion, int *minorversion, int *release, int *build); +typedef lprec * (__WINAPI make_lp_func)(int rows, int columns); +typedef void (__WINAPI print_constraints_func)(lprec *lp, int columns); +typedef MYBOOL (__WINAPI print_debugdump_func)(lprec *lp, char *filename); +typedef void (__WINAPI print_duals_func)(lprec *lp); +typedef void (__WINAPI print_lp_func)(lprec *lp); +typedef void (__WINAPI print_objective_func)(lprec *lp); +typedef void (__WINAPI print_scales_func)(lprec *lp); +typedef void (__WINAPI print_solution_func)(lprec *lp, int columns); +typedef void (__WINAPI print_str_func)(lprec *lp, char *str); +typedef void (__WINAPI print_tableau_func)(lprec *lp); +typedef void (__WINAPI put_abortfunc_func)(lprec *lp, lphandle_intfunc newctrlc, void *ctrlchandle); +typedef void (__WINAPI put_bb_nodefunc_func)(lprec *lp, lphandleint_intfunc newnode, void *bbnodehandle); +typedef void (__WINAPI put_bb_branchfunc_func)(lprec *lp, lphandleint_intfunc newbranch, void *bbbranchhandle); +typedef void (__WINAPI put_logfunc_func)(lprec *lp, lphandlestr_func newlog, void *loghandle); +typedef void (__WINAPI put_msgfunc_func)(lprec *lp, lphandleint_func newmsg, void *msghandle, int mask); +typedef MYBOOL (__WINAPI read_LPhandle_func)(lprec **lp, FILE *filehandle, int verbose, char *lp_name); +typedef MYBOOL (__WINAPI read_MPShandle_func)(lprec **lp, FILE *filehandle, int typeMPS, int verbose); +typedef lprec * (__WINAPI read_XLI_func)(char *xliname, char *modelname, char *dataname, char *options, int verbose); +typedef MYBOOL (__WINAPI read_basis_func)(lprec *lp, char *filename, char *info); +typedef void (__WINAPI reset_basis_func)(lprec *lp); +typedef MYBOOL (__WINAPI read_params_func)(lprec *lp, char *filename, char *options); +typedef void (__WINAPI reset_params_func)(lprec *lp); +typedef MYBOOL (__WINAPI resize_lp_func)(lprec *lp, int rows, int columns); +typedef MYBOOL (__WINAPI set_add_rowmode_func)(lprec *lp, MYBOOL turnon); +typedef void (__WINAPI set_anti_degen_func)(lprec *lp, int anti_degen); +typedef int (__WINAPI set_basisvar_func)(lprec *lp, int basisPos, int enteringCol); +typedef MYBOOL (__WINAPI set_basis_func)(lprec *lp, int *bascolumn, MYBOOL nonbasic); +typedef void (__WINAPI set_basiscrash_func)(lprec *lp, int mode); +typedef void (__WINAPI set_bb_depthlimit_func)(lprec *lp, int bb_maxlevel); +typedef void (__WINAPI set_bb_floorfirst_func)(lprec *lp, int bb_floorfirst); +typedef void (__WINAPI set_bb_rule_func)(lprec *lp, int bb_rule); +typedef MYBOOL (__WINAPI set_BFP_func)(lprec *lp, char *filename); +typedef MYBOOL (__WINAPI set_binary_func)(lprec *lp, int colnr, MYBOOL must_be_bin); +typedef MYBOOL (__WINAPI set_bounds_func)(lprec *lp, int colnr, REAL lower, REAL upper); +typedef void (__WINAPI set_bounds_tighter_func)(lprec *lp, MYBOOL tighten); +typedef void (__WINAPI set_break_at_first_func)(lprec *lp, MYBOOL break_at_first); +typedef void (__WINAPI set_break_at_value_func)(lprec *lp, REAL break_at_value); +typedef MYBOOL (__WINAPI set_column_func)(lprec *lp, int colnr, REAL *column); +typedef MYBOOL (__WINAPI set_columnex_func)(lprec *lp, int colnr, int count, REAL *column, int *rowno); +typedef MYBOOL (__WINAPI set_col_name_func)(lprec *lp, int colnr, char *new_name); +typedef MYBOOL (__WINAPI set_constr_type_func)(lprec *lp, int rownr, int con_type); +typedef void (__WINAPI set_debug_func)(lprec *lp, MYBOOL debug); +typedef void (__WINAPI set_epsb_func)(lprec *lp, REAL epsb); +typedef void (__WINAPI set_epsd_func)(lprec *lp, REAL epsd); +typedef void (__WINAPI set_epsel_func)(lprec *lp, REAL epsel); +typedef void (__WINAPI set_epsint_func)(lprec *lp, REAL epsint); +typedef MYBOOL (__WINAPI set_epslevel_func)(lprec *lp, int epslevel); +typedef void (__WINAPI set_epsperturb_func)(lprec *lp, REAL epsperturb); +typedef void (__WINAPI set_epspivot_func)(lprec *lp, REAL epspivot); +typedef MYBOOL (__WINAPI set_unbounded_func)(lprec *lp, int colnr); +typedef void (__WINAPI set_improve_func)(lprec *lp, int improve); +typedef void (__WINAPI set_infinite_func)(lprec *lp, REAL infinite); +typedef MYBOOL (__WINAPI set_int_func)(lprec *lp, int colnr, MYBOOL must_be_int); +typedef void (__WINAPI set_lag_trace_func)(lprec *lp, MYBOOL lag_trace); +typedef MYBOOL (__WINAPI set_lowbo_func)(lprec *lp, int colnr, REAL value); +typedef MYBOOL (__WINAPI set_lp_name_func)(lprec *lp, char *lpname); +typedef MYBOOL (__WINAPI set_mat_func)(lprec *lp, int row, int column, REAL value); +typedef void (__WINAPI set_maxim_func)(lprec *lp); +typedef void (__WINAPI set_maxpivot_func)(lprec *lp, int max_num_inv); +typedef void (__WINAPI set_minim_func)(lprec *lp); +typedef void (__WINAPI set_mip_gap_func)(lprec *lp, MYBOOL absolute, REAL mip_gap); +typedef MYBOOL (__WINAPI set_multiprice_func)(lprec *lp, int multiblockdiv); +typedef void (__WINAPI set_negrange_func)(lprec *lp, REAL negrange); +typedef MYBOOL (__WINAPI set_obj_func)(lprec *lp, int colnr, REAL value); +typedef void (__WINAPI set_obj_bound_func)(lprec *lp, REAL obj_bound); +typedef MYBOOL (__WINAPI set_obj_fn_func)(lprec *lp, REAL *row); +typedef MYBOOL (__WINAPI set_obj_fnex_func)(lprec *lp, int count, REAL *row, int *colno); +typedef void (__WINAPI set_obj_in_basis_func)(lprec *lp, MYBOOL obj_in_basis); +typedef MYBOOL (__WINAPI set_outputfile_func)(lprec *lp, char *filename); +typedef void (__WINAPI set_outputstream_func)(lprec *lp, FILE *stream); +typedef MYBOOL (__WINAPI set_partialprice_func)(lprec *lp, int blockcount, int *blockstart, MYBOOL isrow); +typedef void (__WINAPI set_pivoting_func)(lprec *lp, int piv_rule); +typedef void (__WINAPI set_preferdual_func)(lprec *lp, MYBOOL dodual); +typedef void (__WINAPI set_presolve_func)(lprec *lp, int presolvemode, int maxloops); +typedef void (__WINAPI set_print_sol_func)(lprec *lp, int print_sol); +typedef MYBOOL (__WINAPI set_pseudocosts_func)(lprec *lp, REAL *clower, REAL *cupper, int *updatelimit); +typedef MYBOOL (__WINAPI set_rh_func)(lprec *lp, int rownr, REAL value); +typedef MYBOOL (__WINAPI set_rh_range_func)(lprec *lp, int rownr, REAL deltavalue); +typedef void (__WINAPI set_rh_vec_func)(lprec *lp, REAL *rh); +typedef MYBOOL (__WINAPI set_row_func)(lprec *lp, int rownr, REAL *row); +typedef MYBOOL (__WINAPI set_rowex_func)(lprec *lp, int rownr, int count, REAL *row, int *colno); +typedef MYBOOL (__WINAPI set_row_name_func)(lprec *lp, int rownr, char *new_name); +typedef void (__WINAPI set_scalelimit_func)(lprec *lp, REAL scalelimit); +typedef void (__WINAPI set_scaling_func)(lprec *lp, int scalemode); +typedef MYBOOL (__WINAPI set_semicont_func)(lprec *lp, int colnr, MYBOOL must_be_sc); +typedef void (__WINAPI set_sense_func)(lprec *lp, MYBOOL maximize); +typedef void (__WINAPI set_simplextype_func)(lprec *lp, int simplextype); +typedef void (__WINAPI set_solutionlimit_func)(lprec *lp, int limit); +typedef void (__WINAPI set_timeout_func)(lprec *lp, long sectimeout); +typedef void (__WINAPI set_trace_func)(lprec *lp, MYBOOL trace); +typedef MYBOOL (__WINAPI set_upbo_func)(lprec *lp, int colnr, REAL value); +typedef MYBOOL (__WINAPI set_var_branch_func)(lprec *lp, int colnr, int branch_mode); +typedef MYBOOL (__WINAPI set_var_weights_func)(lprec *lp, REAL *weights); +typedef void (__WINAPI set_verbose_func)(lprec *lp, int verbose); +typedef MYBOOL (__WINAPI set_XLI_func)(lprec *lp, char *filename); +typedef int (__WINAPI solve_func)(lprec *lp); +typedef MYBOOL (__WINAPI str_add_column_func)(lprec *lp, char *col_string); +typedef MYBOOL (__WINAPI str_add_constraint_func)(lprec *lp, char *row_string ,int constr_type, REAL rh); +typedef MYBOOL (__WINAPI str_add_lag_con_func)(lprec *lp, char *row_string, int con_type, REAL rhs); +typedef MYBOOL (__WINAPI str_set_obj_fn_func)(lprec *lp, char *row_string); +typedef MYBOOL (__WINAPI str_set_rh_vec_func)(lprec *lp, char *rh_string); +typedef REAL (__WINAPI time_elapsed_func)(lprec *lp); +typedef void (__WINAPI unscale_func)(lprec *lp); +typedef MYBOOL (__WINAPI write_lp_func)(lprec *lp, char *filename); +typedef MYBOOL (__WINAPI write_LP_func)(lprec *lp, FILE *output); +typedef MYBOOL (__WINAPI write_mps_func)(lprec *lp, char *filename); +typedef MYBOOL (__WINAPI write_MPS_func)(lprec *lp, FILE *output); +typedef MYBOOL (__WINAPI write_freemps_func)(lprec *lp, char *filename); +typedef MYBOOL (__WINAPI write_freeMPS_func)(lprec *lp, FILE *output); +typedef MYBOOL (__WINAPI write_XLI_func)(lprec *lp, char *filename, char *options, MYBOOL results); +typedef MYBOOL (__WINAPI write_basis_func)(lprec *lp, char *filename); +typedef MYBOOL (__WINAPI write_params_func)(lprec *lp, char *filename, char *options); + + +/* Prototypes for callbacks from basis inverse/factorization libraries */ +/* ------------------------------------------------------------------------- */ +typedef MYBOOL (__WINAPI userabortfunc)(lprec *lp, int level); +typedef void (__VACALL reportfunc)(lprec *lp, int level, char *format, ...); +typedef char * (__VACALL explainfunc)(lprec *lp, char *format, ...); +typedef int (__WINAPI getvectorfunc)(lprec *lp, int varin, REAL *pcol, int *nzlist, int *maxabs); +typedef int (__WINAPI getpackedfunc)(lprec *lp, int j, int rn[], double bj[]); +typedef REAL (__WINAPI get_OF_activefunc)(lprec *lp, int varnr, REAL mult); +typedef int (__WINAPI getMDOfunc)(lprec *lp, MYBOOL *usedpos, int *colorder, int *size, MYBOOL symmetric); +typedef MYBOOL (__WINAPI invertfunc)(lprec *lp, MYBOOL shiftbounds, MYBOOL final); +typedef void (__WINAPI set_actionfunc)(int *actionvar, int actionmask); +typedef MYBOOL (__WINAPI is_actionfunc)(int actionvar, int testmask); +typedef void (__WINAPI clear_actionfunc)(int *actionvar, int actionmask); + + +/* Prototypes for basis inverse/factorization libraries */ +/* ------------------------------------------------------------------------- */ +typedef char *(BFP_CALLMODEL BFPchar)(void); +typedef void (BFP_CALLMODEL BFP_lp)(lprec *lp); +typedef void (BFP_CALLMODEL BFP_lpint)(lprec *lp, int newsize); +typedef int (BFP_CALLMODEL BFPint_lp)(lprec *lp); +typedef int (BFP_CALLMODEL BFPint_lpint)(lprec *lp, int kind); +typedef REAL (BFP_CALLMODEL BFPreal_lp)(lprec *lp); +typedef REAL *(BFP_CALLMODEL BFPrealp_lp)(lprec *lp); +typedef void (BFP_CALLMODEL BFP_lpbool)(lprec *lp, MYBOOL maximum); +typedef int (BFP_CALLMODEL BFPint_lpbool)(lprec *lp, MYBOOL maximum); +typedef int (BFP_CALLMODEL BFPint_lpintintboolbool)(lprec *lp, int uservars, int Bsize, MYBOOL *usedpos, MYBOOL final); +typedef void (BFP_CALLMODEL BFP_lprealint)(lprec *lp, REAL *pcol, int *nzidx); +typedef void (BFP_CALLMODEL BFP_lprealintrealint)(lprec *lp, REAL *prow, int *pnzidx, REAL *drow, int *dnzidx); +typedef MYBOOL (BFP_CALLMODEL BFPbool_lp)(lprec *lp); +typedef MYBOOL (BFP_CALLMODEL BFPbool_lpbool)(lprec *lp, MYBOOL changesign); +typedef MYBOOL (BFP_CALLMODEL BFPbool_lpint)(lprec *lp, int size); +typedef MYBOOL (BFP_CALLMODEL BFPbool_lpintintchar)(lprec *lp, int size, int deltasize, char *options); +typedef MYBOOL (BFP_CALLMODEL BFPbool_lpintintint)(lprec *lp, int size, int deltasize, int sizeofvar); +typedef LREAL (BFP_CALLMODEL BFPlreal_lpintintreal)(lprec *lp, int row_nr, int col_nr, REAL *pcol); +typedef REAL (BFP_CALLMODEL BFPreal_lplrealreal)(lprec *lp, LREAL theta, REAL *pcol); + +typedef int (BFP_CALLMODEL getcolumnex_func)(lprec *lp, int colnr, REAL *nzvalues, int *nzrows, int *mapin); +typedef int (BFP_CALLMODEL BFPint_lpintrealcbintint)(lprec *lp, int items, getcolumnex_func cb, int *maprow, int*mapcol); + +/* Prototypes for external language libraries */ +/* ------------------------------------------------------------------------- */ +typedef char *(XLI_CALLMODEL XLIchar)(void); +typedef MYBOOL (XLI_CALLMODEL XLIbool_lpintintint)(lprec* lp, int size, int deltasize, int sizevar); +typedef MYBOOL (XLI_CALLMODEL XLIbool_lpcharcharcharint)(lprec *lp, char *modelname, char *dataname, char *options, int verbose); +typedef MYBOOL (XLI_CALLMODEL XLIbool_lpcharcharbool)(lprec *lp, char *filename, char *options, MYBOOL results); + + +/* Main lp_solve prototypes and function definitions */ +/* ------------------------------------------------------------------------- */ +struct _lprec +{ + /* Full list of exported functions made available in a quasi object-oriented fashion */ + add_column_func *add_column; + add_columnex_func *add_columnex; + add_constraint_func *add_constraint; + add_constraintex_func *add_constraintex; + add_lag_con_func *add_lag_con; + add_SOS_func *add_SOS; + column_in_lp_func *column_in_lp; + copy_lp_func *copy_lp; + default_basis_func *default_basis; + del_column_func *del_column; + del_constraint_func *del_constraint; + delete_lp_func *delete_lp; + dualize_lp_func *dualize_lp; + free_lp_func *free_lp; + get_anti_degen_func *get_anti_degen; + get_basis_func *get_basis; + get_basiscrash_func *get_basiscrash; + get_bb_depthlimit_func *get_bb_depthlimit; + get_bb_floorfirst_func *get_bb_floorfirst; + get_bb_rule_func *get_bb_rule; + get_bounds_tighter_func *get_bounds_tighter; + get_break_at_value_func *get_break_at_value; + get_col_name_func *get_col_name; + get_columnex_func *get_columnex; + get_constr_type_func *get_constr_type; + get_constr_value_func *get_constr_value; + get_constraints_func *get_constraints; + get_dual_solution_func *get_dual_solution; + get_epsb_func *get_epsb; + get_epsd_func *get_epsd; + get_epsel_func *get_epsel; + get_epsint_func *get_epsint; + get_epsperturb_func *get_epsperturb; + get_epspivot_func *get_epspivot; + get_improve_func *get_improve; + get_infinite_func *get_infinite; + get_lambda_func *get_lambda; + get_lowbo_func *get_lowbo; + get_lp_index_func *get_lp_index; + get_lp_name_func *get_lp_name; + get_Lrows_func *get_Lrows; + get_mat_func *get_mat; + get_mat_byindex_func *get_mat_byindex; + get_max_level_func *get_max_level; + get_maxpivot_func *get_maxpivot; + get_mip_gap_func *get_mip_gap; + get_multiprice_func *get_multiprice; + get_nameindex_func *get_nameindex; + get_Ncolumns_func *get_Ncolumns; + get_negrange_func *get_negrange; + get_nz_func *get_nonzeros; + get_Norig_columns_func *get_Norig_columns; + get_Norig_rows_func *get_Norig_rows; + get_Nrows_func *get_Nrows; + get_obj_bound_func *get_obj_bound; + get_objective_func *get_objective; + get_orig_index_func *get_orig_index; + get_origcol_name_func *get_origcol_name; + get_origrow_name_func *get_origrow_name; + get_partialprice_func *get_partialprice; + get_pivoting_func *get_pivoting; + get_presolve_func *get_presolve; + get_presolveloops_func *get_presolveloops; + get_primal_solution_func *get_primal_solution; + get_print_sol_func *get_print_sol; + get_pseudocosts_func *get_pseudocosts; + get_ptr_constraints_func *get_ptr_constraints; + get_ptr_dual_solution_func *get_ptr_dual_solution; + get_ptr_lambda_func *get_ptr_lambda; + get_ptr_primal_solution_func *get_ptr_primal_solution; + get_ptr_sensitivity_obj_func *get_ptr_sensitivity_obj; + get_ptr_sensitivity_objex_func *get_ptr_sensitivity_objex; + get_ptr_sensitivity_rhs_func *get_ptr_sensitivity_rhs; + get_ptr_variables_func *get_ptr_variables; + get_rh_func *get_rh; + get_rh_range_func *get_rh_range; + get_row_func *get_row; + get_rowex_func *get_rowex; + get_row_name_func *get_row_name; + get_scalelimit_func *get_scalelimit; + get_scaling_func *get_scaling; + get_sensitivity_obj_func *get_sensitivity_obj; + get_sensitivity_objex_func *get_sensitivity_objex; + get_sensitivity_rhs_func *get_sensitivity_rhs; + get_simplextype_func *get_simplextype; + get_solutioncount_func *get_solutioncount; + get_solutionlimit_func *get_solutionlimit; + get_status_func *get_status; + get_statustext_func *get_statustext; + get_timeout_func *get_timeout; + get_total_iter_func *get_total_iter; + get_total_nodes_func *get_total_nodes; + get_upbo_func *get_upbo; + get_var_branch_func *get_var_branch; + get_var_dualresult_func *get_var_dualresult; + get_var_primalresult_func *get_var_primalresult; + get_var_priority_func *get_var_priority; + get_variables_func *get_variables; + get_verbose_func *get_verbose; + get_working_objective_func *get_working_objective; + has_BFP_func *has_BFP; + has_XLI_func *has_XLI; + is_add_rowmode_func *is_add_rowmode; + is_anti_degen_func *is_anti_degen; + is_binary_func *is_binary; + is_break_at_first_func *is_break_at_first; + is_constr_type_func *is_constr_type; + is_debug_func *is_debug; + is_feasible_func *is_feasible; + is_infinite_func *is_infinite; + is_int_func *is_int; + is_integerscaling_func *is_integerscaling; + is_lag_trace_func *is_lag_trace; + is_maxim_func *is_maxim; + is_nativeBFP_func *is_nativeBFP; + is_nativeXLI_func *is_nativeXLI; + is_negative_func *is_negative; + is_obj_in_basis_func *is_obj_in_basis; + is_piv_mode_func *is_piv_mode; + is_piv_rule_func *is_piv_rule; + is_presolve_func *is_presolve; + is_scalemode_func *is_scalemode; + is_scaletype_func *is_scaletype; + is_semicont_func *is_semicont; + is_SOS_var_func *is_SOS_var; + is_trace_func *is_trace; + is_unbounded_func *is_unbounded; + is_use_names_func *is_use_names; + lp_solve_version_func *lp_solve_version; + make_lp_func *make_lp; + print_constraints_func *print_constraints; + print_debugdump_func *print_debugdump; + print_duals_func *print_duals; + print_lp_func *print_lp; + print_objective_func *print_objective; + print_scales_func *print_scales; + print_solution_func *print_solution; + print_str_func *print_str; + print_tableau_func *print_tableau; + put_abortfunc_func *put_abortfunc; + put_bb_nodefunc_func *put_bb_nodefunc; + put_bb_branchfunc_func *put_bb_branchfunc; + put_logfunc_func *put_logfunc; + put_msgfunc_func *put_msgfunc; + read_LPhandle_func *read_LPhandle; + read_MPShandle_func *read_MPShandle; + read_XLI_func *read_XLI; + read_params_func *read_params; + read_basis_func *read_basis; + reset_basis_func *reset_basis; + reset_params_func *reset_params; + resize_lp_func *resize_lp; + set_add_rowmode_func *set_add_rowmode; + set_anti_degen_func *set_anti_degen; + set_basisvar_func *set_basisvar; + set_basis_func *set_basis; + set_basiscrash_func *set_basiscrash; + set_bb_depthlimit_func *set_bb_depthlimit; + set_bb_floorfirst_func *set_bb_floorfirst; + set_bb_rule_func *set_bb_rule; + set_BFP_func *set_BFP; + set_binary_func *set_binary; + set_bounds_func *set_bounds; + set_bounds_tighter_func *set_bounds_tighter; + set_break_at_first_func *set_break_at_first; + set_break_at_value_func *set_break_at_value; + set_column_func *set_column; + set_columnex_func *set_columnex; + set_col_name_func *set_col_name; + set_constr_type_func *set_constr_type; + set_debug_func *set_debug; + set_epsb_func *set_epsb; + set_epsd_func *set_epsd; + set_epsel_func *set_epsel; + set_epsint_func *set_epsint; + set_epslevel_func *set_epslevel; + set_epsperturb_func *set_epsperturb; + set_epspivot_func *set_epspivot; + set_unbounded_func *set_unbounded; + set_improve_func *set_improve; + set_infinite_func *set_infinite; + set_int_func *set_int; + set_lag_trace_func *set_lag_trace; + set_lowbo_func *set_lowbo; + set_lp_name_func *set_lp_name; + set_mat_func *set_mat; + set_maxim_func *set_maxim; + set_maxpivot_func *set_maxpivot; + set_minim_func *set_minim; + set_mip_gap_func *set_mip_gap; + set_multiprice_func *set_multiprice; + set_negrange_func *set_negrange; + set_obj_bound_func *set_obj_bound; + set_obj_fn_func *set_obj_fn; + set_obj_fnex_func *set_obj_fnex; + set_obj_func *set_obj; + set_obj_in_basis_func *set_obj_in_basis; + set_outputfile_func *set_outputfile; + set_outputstream_func *set_outputstream; + set_partialprice_func *set_partialprice; + set_pivoting_func *set_pivoting; + set_preferdual_func *set_preferdual; + set_presolve_func *set_presolve; + set_print_sol_func *set_print_sol; + set_pseudocosts_func *set_pseudocosts; + set_rh_func *set_rh; + set_rh_range_func *set_rh_range; + set_rh_vec_func *set_rh_vec; + set_row_func *set_row; + set_rowex_func *set_rowex; + set_row_name_func *set_row_name; + set_scalelimit_func *set_scalelimit; + set_scaling_func *set_scaling; + set_semicont_func *set_semicont; + set_sense_func *set_sense; + set_simplextype_func *set_simplextype; + set_solutionlimit_func *set_solutionlimit; + set_timeout_func *set_timeout; + set_trace_func *set_trace; + set_upbo_func *set_upbo; + set_use_names_func *set_use_names; + set_var_branch_func *set_var_branch; + set_var_weights_func *set_var_weights; + set_verbose_func *set_verbose; + set_XLI_func *set_XLI; + solve_func *solve; + str_add_column_func *str_add_column; + str_add_constraint_func *str_add_constraint; + str_add_lag_con_func *str_add_lag_con; + str_set_obj_fn_func *str_set_obj_fn; + str_set_rh_vec_func *str_set_rh_vec; + time_elapsed_func *time_elapsed; + unscale_func *unscale; + write_lp_func *write_lp; + write_LP_func *write_LP; + write_mps_func *write_mps; + write_MPS_func *write_MPS; + write_freemps_func *write_freemps; + write_freeMPS_func *write_freeMPS; + write_XLI_func *write_XLI; + write_basis_func *write_basis; + write_params_func *write_params; + + /* Spacer */ + int *alignmentspacer; + + /* Problem description */ + char *lp_name; /* The name of the model */ + + /* Problem sizes */ + int sum; /* The total number of variables, including slacks */ + int rows; + int columns; + int equalities; /* No of non-Lagrangean equality constraints in the problem */ + int boundedvars; /* Count of bounded variables */ + int INTfuture1; + + /* Memory allocation sizes */ + int sum_alloc; /* The allocated memory for row+column-sized data */ + int rows_alloc; /* The allocated memory for row-sized data */ + int columns_alloc; /* The allocated memory for column-sized data */ + + /* Model status and solver result variables */ + MYBOOL source_is_file; /* The base model was read from a file */ + MYBOOL model_is_pure; /* The model has been built entirely from row and column additions */ + MYBOOL model_is_valid; /* Has this lp pased the 'test' */ + MYBOOL tighten_on_set; /* Specify if bounds will be tightened or overriden at bound setting */ + MYBOOL names_used; /* Flag to indicate if names for rows and columns are used */ + MYBOOL use_row_names; /* Flag to indicate if names for rows are used */ + MYBOOL use_col_names; /* Flag to indicate if names for columns are used */ + + MYBOOL lag_trace; /* Print information on Lagrange progression */ + MYBOOL spx_trace; /* Print information on simplex progression */ + MYBOOL bb_trace; /* TRUE to print extra debug information */ + MYBOOL streamowned; /* TRUE if the handle should be closed at delete_lp() */ + MYBOOL obj_in_basis; /* TRUE if the objective function is in the basis matrix */ + + int spx_status; /* Simplex solver feasibility/mode code */ + int lag_status; /* Extra status variable for lag_solve */ + int solutioncount; /* number of equal-valued solutions found (up to solutionlimit) */ + int solutionlimit; /* upper number of equal-valued solutions kept track of */ + + REAL real_solution; /* Optimal non-MIP solution base */ + REAL *solution; /* sum_alloc+1 : Solution array of the next to optimal LP, + Index 0 : Objective function value, + Indeces 1..rows : Slack variable values, + Indeced rows+1..sum : Variable values */ + REAL *best_solution; /* sum_alloc+1 : Solution array of optimal 'Integer' LP, + structured as the solution array above */ + REAL *full_solution; /* sum_alloc+1 : Final solution array expanded for deleted variables */ + REAL *edgeVector; /* Array of reduced cost scaling norms (DEVEX and Steepest Edge) */ + + REAL *drow; /* sum+1: Reduced costs of the last simplex */ + int *nzdrow; /* sum+1: Indeces of non-zero reduced costs of the last simplex */ + REAL *duals; /* rows_alloc+1 : The dual variables of the last LP */ + REAL *full_duals; /* sum_alloc+1: Final duals array expanded for deleted variables */ + REAL *dualsfrom; /* sum_alloc+1 :The sensitivity on dual variables/reduced costs + of the last LP */ + REAL *dualstill; /* sum_alloc+1 :The sensitivity on dual variables/reduced costs + of the last LP */ + REAL *objfrom; /* columns_alloc+1 :The sensitivity on objective function + of the last LP */ + REAL *objtill; /* columns_alloc+1 :The sensitivity on objective function + of the last LP */ + REAL *objfromvalue; /* columns_alloc+1 :The value of the variables when objective value + is at its from value of the last LP */ + REAL *orig_obj; /* Unused pointer - Placeholder for OF not part of B */ + REAL *obj; /* Special vector used to temporarily change the OF vector */ + + COUNTER current_iter; /* Number of iterations in the current/last simplex */ + COUNTER total_iter; /* Number of iterations over all B&B steps */ + COUNTER current_bswap; /* Number of bound swaps in the current/last simplex */ + COUNTER total_bswap; /* Number of bount swaps over all B&B steps */ + int solvecount; /* The number of solve() performed in this model */ + int max_pivots; /* Number of pivots between refactorizations of the basis */ + + /* Various execution parameters */ + int simplex_strategy; /* Set desired combination of primal and dual simplex algorithms */ + int simplex_mode; /* Specifies the current simplex mode during solve; see simplex_strategy */ + int verbose; /* Set amount of run-time messages and results */ + int print_sol; /* TRUE to print optimal solution; AUTOMATIC skips zeros */ + FILE *outstream; /* Output stream, initialized to STDOUT */ + + /* Main Branch and Bound settings */ + MYBOOL *bb_varbranch; /* Determines branching strategy at the individual variable level; + the setting here overrides the bb_floorfirst setting */ + int piv_strategy; /* Strategy for selecting row and column entering/leaving */ + int _piv_rule_; /* Internal working rule-part of piv_strategy above */ + int bb_rule; /* Rule for selecting B&B variables */ + MYBOOL bb_floorfirst; /* Set BRANCH_FLOOR for B&B to set variables to floor bound first; + conversely with BRANCH_CEILING, the ceiling value is set first */ + MYBOOL bb_breakfirst; /* TRUE to stop at first feasible solution */ + MYBOOL _piv_left_; /* Internal variable indicating active pricing loop order */ + MYBOOL BOOLfuture1; + + REAL scalelimit; /* Relative convergence criterion for iterated scaling */ + int scalemode; /* OR-ed codes for data scaling */ + int improve; /* Set to non-zero for iterative improvement */ + int anti_degen; /* Anti-degen strategy (or none) TRUE to avoid cycling */ + int do_presolve; /* PRESOLVE_ parameters for LP presolving */ + int presolveloops; /* Maximum number of presolve loops */ + + int perturb_count; /* The number of bound relaxation retries performed */ + + /* Row and column names storage variables */ + hashelem **row_name; /* rows_alloc+1 */ + hashelem **col_name; /* columns_alloc+1 */ + hashtable *rowname_hashtab; /* hash table to store row names */ + hashtable *colname_hashtab; /* hash table to store column names */ + + /* Optionally specify continuous rows/column blocks for partial pricing */ + partialrec *rowblocks; + partialrec *colblocks; + + /* Row and column type codes */ + MYBOOL *var_type; /* sum_alloc+1 : TRUE if variable must be integer */ + + /* Data for multiple pricing */ + multirec *multivars; + int multiblockdiv; /* The divisor used to set or augment pricing block */ + + /* Variable (column) parameters */ + int fixedvars; /* The current number of basic fixed variables in the model */ + int int_vars; /* Number of variables required to be integer */ + + int sc_vars; /* Number of semi-continuous variables */ + REAL *sc_lobound; /* sum_columns+1 : TRUE if variable is semi-continuous; + value replaced by conventional lower bound during solve */ + int *var_is_free; /* columns+1: Index of twin variable if variable is free */ + int *var_priority; /* columns: Priority-mapping of variables */ + + SOSgroup *GUB; /* Pointer to record containing GUBs */ + + int sos_vars; /* Number of variables in the sos_priority list */ + int sos_ints; /* Number of integers in SOS'es above */ + SOSgroup *SOS; /* Pointer to record containing all SOS'es */ + int *sos_priority; /* Priority-sorted list of variables (no duplicates) */ + + /* Optionally specify list of active rows/columns used in multiple pricing */ + REAL *bsolveVal; /* rows+1: bsolved solution vector for reduced costs */ + int *bsolveIdx; /* rows+1: Non-zero indeces of bsolveVal */ + + /* RHS storage */ + REAL *orig_rhs; /* rows_alloc+1 : The RHS after scaling and sign + changing, but before 'Bound transformation' */ + LREAL *rhs; /* rows_alloc+1 : The RHS of the current simplex tableau */ + + /* Row (constraint) parameters */ + int *row_type; /* rows_alloc+1 : Row/constraint type coding */ + + /* Optionally specify data for dual long-step */ + multirec *longsteps; + + /* Original and working row and variable bounds */ + REAL *orig_upbo; /* sum_alloc+1 : Bound before transformations */ + REAL *upbo; /* " " : Upper bound after transformation and B&B work */ + REAL *orig_lowbo; /* " " */ + REAL *lowbo; /* " " : Lower bound after transformation and B&B work */ + + /* User data and basis factorization matrices (ETA or LU, product form) */ + MATrec *matA; + INVrec *invB; + + /* Basis and bounds */ + BBrec *bb_bounds; /* The linked list of B&B bounds */ + BBrec *rootbounds; /* The bounds at the lowest B&B level */ + basisrec *bb_basis; /* The linked list of B&B bases */ + basisrec *rootbasis; + OBJmonrec *monitor; /* Objective monitoring record for stalling/degeneracy handling */ + + /* Scaling parameters */ + REAL *scalars; /* sum_alloc+1:0..Rows the scaling of the rows, + Rows+1..Sum the scaling of the columns */ + MYBOOL scaling_used; /* TRUE if scaling is used */ + MYBOOL columns_scaled; /* TRUE if the columns are scaled too */ + MYBOOL varmap_locked; /* Determines whether the var_to_orig and orig_to_var are fixed */ + + /* Variable state information */ + MYBOOL basis_valid; /* TRUE is the basis is still valid */ + int crashmode; /* Basis crashing mode (or none) */ + int *var_basic; /* rows_alloc+1: The list of columns in the basis */ + REAL *val_nonbasic; /* Array to store current values of non-basic variables */ + MYBOOL *is_basic; /* sum_alloc+1: TRUE if the column is in the basis */ + MYBOOL *is_lower; /* " " : TRUE if the variable is at its + lower bound (or in the basis), FALSE otherwise */ + + /* Simplex basis indicators */ + int *rejectpivot; /* List of unacceptable pivot choices due to division-by-zero */ + BBPSrec *bb_PseudoCost; /* Data structure for costing of node branchings */ + int bb_PseudoUpdates; /* Maximum number of updates for pseudo-costs */ + int bb_strongbranches; /* The number of strong B&B branches performed */ + int is_strongbranch; /* Are we currently in a strong branch mode? */ + int bb_improvements; /* The number of discrete B&B objective improvement steps */ + + /* Solver working variables */ + REAL rhsmax; /* The maximum |value| of the rhs vector at any iteration */ + REAL suminfeas; /* The working sum of primal and dual infeasibilities */ + REAL bigM; /* Original objective weighting in primal phase 1 */ + REAL P1extraVal; /* Phase 1 OF/RHS offset for feasibility */ + int P1extraDim; /* Phase 1 additional columns/rows for feasibility */ + int spx_action; /* ACTION_ variables for the simplex routine */ + MYBOOL spx_perturbed; /* The variable bounds were relaxed/perturbed into this simplex */ + MYBOOL bb_break; /* Solver working variable; signals break of the B&B */ + MYBOOL wasPreprocessed; /* The solve preprocessing was performed */ + MYBOOL wasPresolved; /* The solve presolver was invoked */ + int INTfuture2; + + /* Lagragean solver storage and parameters */ + MATrec *matL; + REAL *lag_rhs; /* Array of Lagrangean rhs vector */ + int *lag_con_type; /* Array of GT, LT or EQ */ + REAL *lambda; /* Lambda values (Lagrangean multipliers) */ + REAL lag_bound; /* The Lagrangian lower OF bound */ + REAL lag_accept; /* The Lagrangian convergence criterion */ + + /* Solver thresholds */ + REAL infinite; /* Limit for dynamic range */ + REAL negrange; /* Limit for negative variable range */ + REAL epsmachine; /* Default machine accuracy */ + REAL epsvalue; /* Input data precision / rounding of data values to 0 */ + REAL epsprimal; /* For rounding RHS values to 0/infeasibility */ + REAL epsdual; /* For rounding reduced costs to zero */ + REAL epspivot; /* Pivot reject tolerance */ + REAL epsperturb; /* Perturbation scalar */ + REAL epssolution; /* The solution tolerance for final validation */ + + /* Branch & Bound working parameters */ + int bb_status; /* Indicator that the last solvelp() gave an improved B&B solution */ + int bb_level; /* Solver B&B working variable (recursion depth) */ + int bb_maxlevel; /* The deepest B&B level of the last solution */ + int bb_limitlevel; /* The maximum B&B level allowed */ + COUNTER bb_totalnodes; /* Total number of nodes processed in B&B */ + int bb_solutionlevel; /* The B&B level of the last / best solution */ + int bb_cutpoolsize; /* Size of the B&B cut pool */ + int bb_cutpoolused; /* Currently used cut pool */ + int bb_constraintOF; /* General purpose B&B parameter (typically for testing) */ + int *bb_cuttype; /* The type of the currently used cuts */ + int *bb_varactive; /* The B&B state of the variable; 0 means inactive */ + DeltaVrec *bb_upperchange; /* Changes to upper bounds during the B&B phase */ + DeltaVrec *bb_lowerchange; /* Changes to lower bounds during the B&B phase */ + + REAL bb_deltaOF; /* Minimum OF step value; computed at beginning of solve() */ + + REAL bb_breakOF; /* User-settable value for the objective function deemed + to be sufficiently good in an integer problem */ + REAL bb_limitOF; /* "Dual" bound / limit to final optimal MIP solution */ + REAL bb_heuristicOF; /* Set initial "at least better than" guess for objective function + (can significantly speed up B&B iterations) */ + REAL bb_parentOF; /* The OF value of the previous BB simplex */ + REAL bb_workOF; /* The unadjusted OF value for the current best solution */ + + /* Internal work arrays allocated as required */ + presolveundorec *presolve_undo; + workarraysrec *workarrays; + + /* MIP parameters */ + REAL epsint; /* Margin of error in determining if a float value is integer */ + REAL mip_absgap; /* Absolute MIP gap */ + REAL mip_relgap; /* Relative MIP gap */ + + /* Time/timer variables and extended status text */ + double timecreate; + double timestart; + double timeheuristic; + double timepresolved; + double timeend; + long sectimeout; + + /* Extended status message text set via explain() */ + char *ex_status; + + /* Refactorization engine interface routines (for dynamic DLL/SO BFPs) */ +#if LoadInverseLib == TRUE + #ifdef WIN32 + HINSTANCE hBFP; + #else + void *hBFP; + #endif +#endif + BFPchar *bfp_name; + BFPbool_lpintintint *bfp_compatible; + BFPbool_lpintintchar *bfp_init; + BFP_lp *bfp_free; + BFPbool_lpint *bfp_resize; + BFPint_lp *bfp_memallocated; + BFPbool_lp *bfp_restart; + BFPbool_lp *bfp_mustrefactorize; + BFPint_lp *bfp_preparefactorization; + BFPint_lpintintboolbool *bfp_factorize; + BFP_lp *bfp_finishfactorization; + BFP_lp *bfp_updaterefactstats; + BFPlreal_lpintintreal *bfp_prepareupdate; + BFPreal_lplrealreal *bfp_pivotRHS; + BFPbool_lpbool *bfp_finishupdate; + BFP_lprealint *bfp_ftran_prepare; + BFP_lprealint *bfp_ftran_normal; + BFP_lprealint *bfp_btran_normal; + BFP_lprealintrealint *bfp_btran_double; + BFPint_lp *bfp_status; + BFPint_lpbool *bfp_nonzeros; + BFPbool_lp *bfp_implicitslack; + BFPint_lp *bfp_indexbase; + BFPint_lp *bfp_rowoffset; + BFPint_lp *bfp_pivotmax; + BFPbool_lpint *bfp_pivotalloc; + BFPint_lp *bfp_colcount; + BFPbool_lp *bfp_canresetbasis; + BFPreal_lp *bfp_efficiency; + BFPrealp_lp *bfp_pivotvector; + BFPint_lp *bfp_pivotcount; + BFPint_lpint *bfp_refactcount; + BFPbool_lp *bfp_isSetI; + BFPint_lpintrealcbintint *bfp_findredundant; + + /* External language interface routines (for dynamic DLL/SO XLIs) */ +#if LoadLanguageLib == TRUE + #ifdef WIN32 + HINSTANCE hXLI; + #else + void *hXLI; + #endif +#endif + XLIchar *xli_name; + XLIbool_lpintintint *xli_compatible; + XLIbool_lpcharcharcharint *xli_readmodel; + XLIbool_lpcharcharbool *xli_writemodel; + + /* Miscellaneous internal functions made available externally */ + userabortfunc *userabort; + reportfunc *report; + explainfunc *explain; + getvectorfunc *get_lpcolumn; + getpackedfunc *get_basiscolumn; + get_OF_activefunc *get_OF_active; + getMDOfunc *getMDO; + invertfunc *invert; + set_actionfunc *set_action; + is_actionfunc *is_action; + clear_actionfunc *clear_action; + + /* User program interface callbacks */ + lphandle_intfunc *ctrlc; + void *ctrlchandle; /* User-specified "owner process ID" */ + lphandlestr_func *writelog; + void *loghandle; /* User-specified "owner process ID" */ + lphandlestr_func *debuginfo; + lphandleint_func *usermessage; + int msgmask; + void *msghandle; /* User-specified "owner process ID" */ + lphandleint_intfunc *bb_usenode; + void *bb_nodehandle; /* User-specified "owner process ID" */ + lphandleint_intfunc *bb_usebranch; + void *bb_branchhandle; /* User-specified "owner process ID" */ + +}; + + +#ifdef __cplusplus +__EXTERN_C { +#endif + + +/* User and system function interfaces */ +/* ------------------------------------------------------------------------- */ + +void __EXPORT_TYPE __WINAPI lp_solve_version(int *majorversion, int *minorversion, int *release, int *build); + +lprec __EXPORT_TYPE * __WINAPI make_lp(int rows, int columns); +MYBOOL __EXPORT_TYPE __WINAPI resize_lp(lprec *lp, int rows, int columns); +int __EXPORT_TYPE __WINAPI get_status(lprec *lp); +char __EXPORT_TYPE * __WINAPI get_statustext(lprec *lp, int statuscode); +MYBOOL __EXPORT_TYPE __WINAPI is_obj_in_basis(lprec *lp); +void __EXPORT_TYPE __WINAPI set_obj_in_basis(lprec *lp, MYBOOL obj_in_basis); +/* Create and initialise a lprec structure defaults */ + +lprec __EXPORT_TYPE * __WINAPI copy_lp(lprec *lp); +MYBOOL __EXPORT_TYPE __WINAPI dualize_lp(lprec *lp); +STATIC MYBOOL memopt_lp(lprec *lp, int rowextra, int colextra, int nzextra); +/* Copy or dualize the lp */ + +void __EXPORT_TYPE __WINAPI delete_lp(lprec *lp); +void __EXPORT_TYPE __WINAPI free_lp(lprec **plp); +/* Remove problem from memory */ + +MYBOOL __EXPORT_TYPE __WINAPI set_lp_name(lprec *lp, char *lpname); +char __EXPORT_TYPE * __WINAPI get_lp_name(lprec *lp); +/* Set and get the problem name */ + +MYBOOL __EXPORT_TYPE __WINAPI has_BFP(lprec *lp); +MYBOOL __EXPORT_TYPE __WINAPI is_nativeBFP(lprec *lp); +MYBOOL __EXPORT_TYPE __WINAPI set_BFP(lprec *lp, char *filename); +/* Set basis factorization engine */ + +lprec __EXPORT_TYPE * __WINAPI read_XLI(char *xliname, char *modelname, char *dataname, char *options, int verbose); +MYBOOL __EXPORT_TYPE __WINAPI write_XLI(lprec *lp, char *filename, char *options, MYBOOL results); +MYBOOL __EXPORT_TYPE __WINAPI has_XLI(lprec *lp); +MYBOOL __EXPORT_TYPE __WINAPI is_nativeXLI(lprec *lp); +MYBOOL __EXPORT_TYPE __WINAPI set_XLI(lprec *lp, char *filename); +/* Set external language interface */ + +MYBOOL __EXPORT_TYPE __WINAPI set_obj(lprec *lp, int colnr, REAL value); +MYBOOL __EXPORT_TYPE __WINAPI set_obj_fn(lprec *lp, REAL *row); +MYBOOL __EXPORT_TYPE __WINAPI set_obj_fnex(lprec *lp, int count, REAL *row, int *colno); +/* set the objective function (Row 0) of the matrix */ +MYBOOL __EXPORT_TYPE __WINAPI str_set_obj_fn(lprec *lp, char *row_string); +/* The same, but with string input */ +void __EXPORT_TYPE __WINAPI set_sense(lprec *lp, MYBOOL maximize); +void __EXPORT_TYPE __WINAPI set_maxim(lprec *lp); +void __EXPORT_TYPE __WINAPI set_minim(lprec *lp); +MYBOOL __EXPORT_TYPE __WINAPI is_maxim(lprec *lp); +/* Set optimization direction for the objective function */ + +MYBOOL __EXPORT_TYPE __WINAPI add_constraint(lprec *lp, REAL *row, int constr_type, REAL rh); +MYBOOL __EXPORT_TYPE __WINAPI add_constraintex(lprec *lp, int count, REAL *row, int *colno, int constr_type, REAL rh); +MYBOOL __EXPORT_TYPE __WINAPI set_add_rowmode(lprec *lp, MYBOOL turnon); +MYBOOL __EXPORT_TYPE __WINAPI is_add_rowmode(lprec *lp); +/* Add a constraint to the problem, row is the constraint row, rh is the right hand side, + constr_type is the type of constraint (LE (<=), GE(>=), EQ(=)) */ +MYBOOL __EXPORT_TYPE __WINAPI str_add_constraint(lprec *lp, char *row_string, int constr_type, REAL rh); +/* The same, but with string input */ + +MYBOOL __EXPORT_TYPE __WINAPI set_row(lprec *lp, int rownr, REAL *row); +MYBOOL __EXPORT_TYPE __WINAPI set_rowex(lprec *lp, int rownr, int count, REAL *row, int *colno); +MYBOOL __EXPORT_TYPE __WINAPI get_row(lprec *lp, int rownr, REAL *row); +int __EXPORT_TYPE __WINAPI get_rowex(lprec *lp, int rownr, REAL *row, int *colno); +/* Fill row with the row row_nr from the problem */ + +MYBOOL __EXPORT_TYPE __WINAPI del_constraint(lprec *lp, int rownr); +STATIC MYBOOL del_constraintex(lprec *lp, LLrec *rowmap); +/* Remove constrain nr del_row from the problem */ + +MYBOOL __EXPORT_TYPE __WINAPI add_lag_con(lprec *lp, REAL *row, int con_type, REAL rhs); +/* add a Lagrangian constraint of form Row' x contype Rhs */ +MYBOOL __EXPORT_TYPE __WINAPI str_add_lag_con(lprec *lp, char *row_string, int con_type, REAL rhs); +/* The same, but with string input */ +void __EXPORT_TYPE __WINAPI set_lag_trace(lprec *lp, MYBOOL lag_trace); +MYBOOL __EXPORT_TYPE __WINAPI is_lag_trace(lprec *lp); +/* Set debugging/tracing mode of the Lagrangean solver */ + +MYBOOL __EXPORT_TYPE __WINAPI set_constr_type(lprec *lp, int rownr, int con_type); +int __EXPORT_TYPE __WINAPI get_constr_type(lprec *lp, int rownr); +REAL __EXPORT_TYPE __WINAPI get_constr_value(lprec *lp, int rownr, int count, REAL *primsolution, int *nzindex); +MYBOOL __EXPORT_TYPE __WINAPI is_constr_type(lprec *lp, int rownr, int mask); +STATIC char *get_str_constr_type(lprec *lp, int con_type); +STATIC int get_constr_class(lprec *lp, int rownr); +STATIC char *get_str_constr_class(lprec *lp, int con_class); +/* Set the type of constraint in row Row (LE, GE, EQ) */ + +MYBOOL __EXPORT_TYPE __WINAPI set_rh(lprec *lp, int rownr, REAL value); +REAL __EXPORT_TYPE __WINAPI get_rh(lprec *lp, int rownr); +/* Set and get the right hand side of a constraint row */ +MYBOOL __EXPORT_TYPE __WINAPI set_rh_range(lprec *lp, int rownr, REAL deltavalue); +REAL __EXPORT_TYPE __WINAPI get_rh_range(lprec *lp, int rownr); +/* Set the RHS range; i.e. the lower and upper bounds of a constraint row */ +void __EXPORT_TYPE __WINAPI set_rh_vec(lprec *lp, REAL *rh); +/* Set the right hand side vector */ +MYBOOL __EXPORT_TYPE __WINAPI str_set_rh_vec(lprec *lp, char *rh_string); +/* The same, but with string input */ + +MYBOOL __EXPORT_TYPE __WINAPI add_column(lprec *lp, REAL *column); +MYBOOL __EXPORT_TYPE __WINAPI add_columnex(lprec *lp, int count, REAL *column, int *rowno); +MYBOOL __EXPORT_TYPE __WINAPI str_add_column(lprec *lp, char *col_string); +/* Add a column to the problem */ + +MYBOOL __EXPORT_TYPE __WINAPI set_column(lprec *lp, int colnr, REAL *column); +MYBOOL __EXPORT_TYPE __WINAPI set_columnex(lprec *lp, int colnr, int count, REAL *column, int *rowno); +/* Overwrite existing column data */ + +int __EXPORT_TYPE __WINAPI column_in_lp(lprec *lp, REAL *column); +/* Returns the column index if column is already present in lp, otherwise 0. + (Does not look at bounds and types, only looks at matrix values */ + +int __EXPORT_TYPE __WINAPI get_columnex(lprec *lp, int colnr, REAL *column, int *nzrow); +MYBOOL __EXPORT_TYPE __WINAPI get_column(lprec *lp, int colnr, REAL *column); +/* Fill column with the column col_nr from the problem */ + +MYBOOL __EXPORT_TYPE __WINAPI del_column(lprec *lp, int colnr); +STATIC MYBOOL del_columnex(lprec *lp, LLrec *colmap); +/* Delete a column */ + +MYBOOL __EXPORT_TYPE __WINAPI set_mat(lprec *lp, int rownr, int colnr, REAL value); +/* Fill in element (Row,Column) of the matrix + Row in [0..Rows] and Column in [1..Columns] */ +REAL __EXPORT_TYPE __WINAPI get_mat(lprec *lp, int rownr, int colnr); +REAL __EXPORT_TYPE __WINAPI get_mat_byindex(lprec *lp, int matindex, MYBOOL isrow, MYBOOL adjustsign); +int __EXPORT_TYPE __WINAPI get_nonzeros(lprec *lp); +/* get a single element from the matrix */ /* Name changed from "mat_elm" by KE */ + +void __EXPORT_TYPE __WINAPI set_bounds_tighter(lprec *lp, MYBOOL tighten); +MYBOOL get_bounds(lprec *lp, int column, REAL *lower, REAL *upper); +MYBOOL __EXPORT_TYPE __WINAPI get_bounds_tighter(lprec *lp); +MYBOOL __EXPORT_TYPE __WINAPI set_upbo(lprec *lp, int colnr, REAL value); +REAL __EXPORT_TYPE __WINAPI get_upbo(lprec *lp, int colnr); +MYBOOL __EXPORT_TYPE __WINAPI set_lowbo(lprec *lp, int colnr, REAL value); +REAL __EXPORT_TYPE __WINAPI get_lowbo(lprec *lp, int colnr); +MYBOOL __EXPORT_TYPE __WINAPI set_bounds(lprec *lp, int colnr, REAL lower, REAL upper); +MYBOOL __EXPORT_TYPE __WINAPI set_unbounded(lprec *lp, int colnr); +MYBOOL __EXPORT_TYPE __WINAPI is_unbounded(lprec *lp, int colnr); +/* Set the upper and lower bounds of a variable */ + +MYBOOL __EXPORT_TYPE __WINAPI set_int(lprec *lp, int colnr, MYBOOL must_be_int); +MYBOOL __EXPORT_TYPE __WINAPI is_int(lprec *lp, int colnr); +MYBOOL __EXPORT_TYPE __WINAPI set_binary(lprec *lp, int colnr, MYBOOL must_be_bin); +MYBOOL __EXPORT_TYPE __WINAPI is_binary(lprec *lp, int colnr); +MYBOOL __EXPORT_TYPE __WINAPI set_semicont(lprec *lp, int colnr, MYBOOL must_be_sc); +MYBOOL __EXPORT_TYPE __WINAPI is_semicont(lprec *lp, int colnr); +MYBOOL __EXPORT_TYPE __WINAPI is_negative(lprec *lp, int colnr); +MYBOOL __EXPORT_TYPE __WINAPI set_var_weights(lprec *lp, REAL *weights); +int __EXPORT_TYPE __WINAPI get_var_priority(lprec *lp, int colnr); +/* Set the type of variable */ + +MYBOOL __EXPORT_TYPE __WINAPI set_pseudocosts(lprec *lp, REAL *clower, REAL *cupper, int *updatelimit); +MYBOOL __EXPORT_TYPE __WINAPI get_pseudocosts(lprec *lp, REAL *clower, REAL *cupper, int *updatelimit); +/* Set initial values for, or get computed pseudocost vectors; + note that setting of pseudocosts can only happen in response to a + call-back function optionally requesting this */ + +int __EXPORT_TYPE __WINAPI add_SOS(lprec *lp, char *name, int sostype, int priority, int count, int *sosvars, REAL *weights); +MYBOOL __EXPORT_TYPE __WINAPI is_SOS_var(lprec *lp, int colnr); +/* Add SOS constraints */ + +MYBOOL __EXPORT_TYPE __WINAPI set_row_name(lprec *lp, int rownr, char *new_name); +char __EXPORT_TYPE * __WINAPI get_row_name(lprec *lp, int rownr); +char __EXPORT_TYPE * __WINAPI get_origrow_name(lprec *lp, int rownr); +/* Set/Get the name of a constraint row */ /* Get added by KE */ + +MYBOOL __EXPORT_TYPE __WINAPI set_col_name(lprec *lp, int colnr, char *new_name); +char __EXPORT_TYPE * __WINAPI get_col_name(lprec *lp, int colnr); +char __EXPORT_TYPE * __WINAPI get_origcol_name(lprec *lp, int colnr); +/* Set/Get the name of a variable column */ /* Get added by KE */ + +void __EXPORT_TYPE __WINAPI unscale(lprec *lp); +/* Undo previous scaling of the problem */ + +void __EXPORT_TYPE __WINAPI set_preferdual(lprec *lp, MYBOOL dodual); +void __EXPORT_TYPE __WINAPI set_simplextype(lprec *lp, int simplextype); +int __EXPORT_TYPE __WINAPI get_simplextype(lprec *lp); +/* Set/Get if lp_solve should prefer the dual simplex over the primal -- added by KE */ + +void __EXPORT_TYPE __WINAPI default_basis(lprec *lp); +void __EXPORT_TYPE __WINAPI set_basiscrash(lprec *lp, int mode); +int __EXPORT_TYPE __WINAPI get_basiscrash(lprec *lp); +int __EXPORT_TYPE __WINAPI set_basisvar(lprec *lp, int basisPos, int enteringCol); +MYBOOL __EXPORT_TYPE __WINAPI set_basis(lprec *lp, int *bascolumn, MYBOOL nonbasic); +MYBOOL __EXPORT_TYPE __WINAPI get_basis(lprec *lp, int *bascolumn, MYBOOL nonbasic); +void __EXPORT_TYPE __WINAPI reset_basis(lprec *lp); +/* Set/Get basis for a re-solved system */ /* Added by KE */ + +MYBOOL __EXPORT_TYPE __WINAPI is_feasible(lprec *lp, REAL *values, REAL threshold); +/* returns TRUE if the vector in values is a feasible solution to the lp */ + +int __EXPORT_TYPE __WINAPI solve(lprec *lp); +/* Solve the problem */ + +REAL __EXPORT_TYPE __WINAPI time_elapsed(lprec *lp); +/* Return the number of seconds since start of solution process */ + +void __EXPORT_TYPE __WINAPI put_bb_nodefunc(lprec *lp, lphandleint_intfunc newnode, void *bbnodehandle); +void __EXPORT_TYPE __WINAPI put_bb_branchfunc(lprec *lp, lphandleint_intfunc newbranch, void *bbbranchhandle); +/* Allow the user to override B&B node and branching decisions */ + +void __EXPORT_TYPE __WINAPI put_abortfunc(lprec *lp, lphandle_intfunc newctrlc, void *ctrlchandle); +/* Allow the user to define an interruption callback function */ + +void __EXPORT_TYPE __WINAPI put_logfunc(lprec *lp, lphandlestr_func newlog, void *loghandle); +/* Allow the user to define a logging function */ + +void __EXPORT_TYPE __WINAPI put_msgfunc(lprec *lp, lphandleint_func newmsg, void *msghandle, int mask); +/* Allow the user to define an event-driven message/reporting */ + +MYBOOL __EXPORT_TYPE __WINAPI get_primal_solution(lprec *lp, REAL *pv); +MYBOOL __EXPORT_TYPE __WINAPI get_ptr_primal_solution(lprec *lp, REAL **pv); +MYBOOL __EXPORT_TYPE __WINAPI get_dual_solution(lprec *lp, REAL *rc); +MYBOOL __EXPORT_TYPE __WINAPI get_ptr_dual_solution(lprec *lp, REAL **rc); +MYBOOL __EXPORT_TYPE __WINAPI get_lambda(lprec *lp, REAL *lambda); +MYBOOL __EXPORT_TYPE __WINAPI get_ptr_lambda(lprec *lp, REAL **lambda); +/* Get the primal, dual/reduced costs and Lambda vectors */ + +/* Read an MPS file */ +lprec __EXPORT_TYPE * __WINAPI read_MPS(char *filename, int verbose); +lprec __EXPORT_TYPE * __WINAPI read_mps(FILE *filename, int verbose); +lprec __EXPORT_TYPE * __WINAPI read_freeMPS(char *filename, int verbose); +lprec __EXPORT_TYPE * __WINAPI read_freemps(FILE *filename, int verbose); + +/* Write a MPS file to output */ +MYBOOL __EXPORT_TYPE __WINAPI write_mps(lprec *lp, char *filename); +MYBOOL __EXPORT_TYPE __WINAPI write_MPS(lprec *lp, FILE *output); +MYBOOL __EXPORT_TYPE __WINAPI write_freemps(lprec *lp, char *filename); +MYBOOL __EXPORT_TYPE __WINAPI write_freeMPS(lprec *lp, FILE *output); + +MYBOOL __EXPORT_TYPE __WINAPI write_lp(lprec *lp, char *filename); +MYBOOL __EXPORT_TYPE __WINAPI write_LP(lprec *lp, FILE *output); + /* Write a LP file to output */ + +MYBOOL __WINAPI LP_readhandle(lprec **lp, FILE *filename, int verbose, char *lp_name); +lprec __EXPORT_TYPE * __WINAPI read_lp(FILE *filename, int verbose, char *lp_name); +lprec __EXPORT_TYPE * __WINAPI read_LP(char *filename, int verbose, char *lp_name); +/* Old-style lp format file parser */ + +MYBOOL __EXPORT_TYPE __WINAPI write_basis(lprec *lp, char *filename); +MYBOOL __EXPORT_TYPE __WINAPI read_basis(lprec *lp, char *filename, char *info); +/* Read and write basis from/to file in CPLEX BAS format */ + +MYBOOL __EXPORT_TYPE __WINAPI write_params(lprec *lp, char *filename, char *options); +MYBOOL __EXPORT_TYPE __WINAPI read_params(lprec *lp, char *filename, char *options); +void __EXPORT_TYPE __WINAPI reset_params(lprec *lp); +/* Read and write parameter file */ + +void __EXPORT_TYPE __WINAPI print_lp(lprec *lp); +void __EXPORT_TYPE __WINAPI print_tableau(lprec *lp); +/* Print the current problem, only useful in very small (test) problems */ + +void __EXPORT_TYPE __WINAPI print_objective(lprec *lp); +void __EXPORT_TYPE __WINAPI print_solution(lprec *lp, int columns); +void __EXPORT_TYPE __WINAPI print_constraints(lprec *lp, int columns); +/* Print the solution to stdout */ + +void __EXPORT_TYPE __WINAPI print_duals(lprec *lp); +/* Print the dual variables of the solution */ + +void __EXPORT_TYPE __WINAPI print_scales(lprec *lp); +/* If scaling is used, print the scaling factors */ + +void __EXPORT_TYPE __WINAPI print_str(lprec *lp, char *str); + +void __EXPORT_TYPE __WINAPI set_outputstream(lprec *lp, FILE *stream); +MYBOOL __EXPORT_TYPE __WINAPI set_outputfile(lprec *lp, char *filename); + +void __EXPORT_TYPE __WINAPI set_verbose(lprec *lp, int verbose); +int __EXPORT_TYPE __WINAPI get_verbose(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_timeout(lprec *lp, long sectimeout); +long __EXPORT_TYPE __WINAPI get_timeout(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_print_sol(lprec *lp, int print_sol); +int __EXPORT_TYPE __WINAPI get_print_sol(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_debug(lprec *lp, MYBOOL debug); +MYBOOL __EXPORT_TYPE __WINAPI is_debug(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_trace(lprec *lp, MYBOOL trace); +MYBOOL __EXPORT_TYPE __WINAPI is_trace(lprec *lp); + +MYBOOL __EXPORT_TYPE __WINAPI print_debugdump(lprec *lp, char *filename); + +void __EXPORT_TYPE __WINAPI set_anti_degen(lprec *lp, int anti_degen); +int __EXPORT_TYPE __WINAPI get_anti_degen(lprec *lp); +MYBOOL __EXPORT_TYPE __WINAPI is_anti_degen(lprec *lp, int testmask); + +void __EXPORT_TYPE __WINAPI set_presolve(lprec *lp, int presolvemode, int maxloops); +int __EXPORT_TYPE __WINAPI get_presolve(lprec *lp); +int __EXPORT_TYPE __WINAPI get_presolveloops(lprec *lp); +MYBOOL __EXPORT_TYPE __WINAPI is_presolve(lprec *lp, int testmask); + +int __EXPORT_TYPE __WINAPI get_orig_index(lprec *lp, int lp_index); +int __EXPORT_TYPE __WINAPI get_lp_index(lprec *lp, int orig_index); + +void __EXPORT_TYPE __WINAPI set_maxpivot(lprec *lp, int max_num_inv); +int __EXPORT_TYPE __WINAPI get_maxpivot(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_obj_bound(lprec *lp, REAL obj_bound); +REAL __EXPORT_TYPE __WINAPI get_obj_bound(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_mip_gap(lprec *lp, MYBOOL absolute, REAL mip_gap); +REAL __EXPORT_TYPE __WINAPI get_mip_gap(lprec *lp, MYBOOL absolute); + +void __EXPORT_TYPE __WINAPI set_bb_rule(lprec *lp, int bb_rule); +int __EXPORT_TYPE __WINAPI get_bb_rule(lprec *lp); + +MYBOOL __EXPORT_TYPE __WINAPI set_var_branch(lprec *lp, int colnr, int branch_mode); +int __EXPORT_TYPE __WINAPI get_var_branch(lprec *lp, int colnr); + +MYBOOL __EXPORT_TYPE __WINAPI is_infinite(lprec *lp, REAL value); +void __EXPORT_TYPE __WINAPI set_infinite(lprec *lp, REAL infinite); +REAL __EXPORT_TYPE __WINAPI get_infinite(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_epsint(lprec *lp, REAL epsint); +REAL __EXPORT_TYPE __WINAPI get_epsint(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_epsb(lprec *lp, REAL epsb); +REAL __EXPORT_TYPE __WINAPI get_epsb(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_epsd(lprec *lp, REAL epsd); +REAL __EXPORT_TYPE __WINAPI get_epsd(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_epsel(lprec *lp, REAL epsel); +REAL __EXPORT_TYPE __WINAPI get_epsel(lprec *lp); + +MYBOOL __EXPORT_TYPE __WINAPI set_epslevel(lprec *lp, int epslevel); + +void __EXPORT_TYPE __WINAPI set_scaling(lprec *lp, int scalemode); +int __EXPORT_TYPE __WINAPI get_scaling(lprec *lp); +MYBOOL __EXPORT_TYPE __WINAPI is_scalemode(lprec *lp, int testmask); +MYBOOL __EXPORT_TYPE __WINAPI is_scaletype(lprec *lp, int scaletype); +MYBOOL __EXPORT_TYPE __WINAPI is_integerscaling(lprec *lp); +void __EXPORT_TYPE __WINAPI set_scalelimit(lprec *lp, REAL scalelimit); +REAL __EXPORT_TYPE __WINAPI get_scalelimit(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_improve(lprec *lp, int improve); +int __EXPORT_TYPE __WINAPI get_improve(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_pivoting(lprec *lp, int piv_rule); +int __EXPORT_TYPE __WINAPI get_pivoting(lprec *lp); +MYBOOL __EXPORT_TYPE __WINAPI set_partialprice(lprec *lp, int blockcount, int *blockstart, MYBOOL isrow); +void __EXPORT_TYPE __WINAPI get_partialprice(lprec *lp, int *blockcount, int *blockstart, MYBOOL isrow); + +MYBOOL __EXPORT_TYPE __WINAPI set_multiprice(lprec *lp, int multiblockdiv); +int __EXPORT_TYPE __WINAPI get_multiprice(lprec *lp, MYBOOL getabssize); + +MYBOOL __WINAPI is_use_names(lprec *lp, MYBOOL isrow); +void __WINAPI set_use_names(lprec *lp, MYBOOL isrow, MYBOOL use_names); + +int __EXPORT_TYPE __WINAPI get_nameindex(lprec *lp, char *varname, MYBOOL isrow); + +MYBOOL __EXPORT_TYPE __WINAPI is_piv_mode(lprec *lp, int testmask); +MYBOOL __EXPORT_TYPE __WINAPI is_piv_rule(lprec *lp, int rule); + +void __EXPORT_TYPE __WINAPI set_break_at_first(lprec *lp, MYBOOL break_at_first); +MYBOOL __EXPORT_TYPE __WINAPI is_break_at_first(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_bb_floorfirst(lprec *lp, int bb_floorfirst); +int __EXPORT_TYPE __WINAPI get_bb_floorfirst(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_bb_depthlimit(lprec *lp, int bb_maxlevel); +int __EXPORT_TYPE __WINAPI get_bb_depthlimit(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_break_at_value(lprec *lp, REAL break_at_value); +REAL __EXPORT_TYPE __WINAPI get_break_at_value(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_negrange(lprec *lp, REAL negrange); +REAL __EXPORT_TYPE __WINAPI get_negrange(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_epsperturb(lprec *lp, REAL epsperturb); +REAL __EXPORT_TYPE __WINAPI get_epsperturb(lprec *lp); + +void __EXPORT_TYPE __WINAPI set_epspivot(lprec *lp, REAL epspivot); +REAL __EXPORT_TYPE __WINAPI get_epspivot(lprec *lp); + +int __EXPORT_TYPE __WINAPI get_max_level(lprec *lp); +COUNTER __EXPORT_TYPE __WINAPI get_total_nodes(lprec *lp); +COUNTER __EXPORT_TYPE __WINAPI get_total_iter(lprec *lp); + +REAL __EXPORT_TYPE __WINAPI get_objective(lprec *lp); +REAL __EXPORT_TYPE __WINAPI get_working_objective(lprec *lp); + +REAL __EXPORT_TYPE __WINAPI get_var_primalresult(lprec *lp, int index); +REAL __EXPORT_TYPE __WINAPI get_var_dualresult(lprec *lp, int index); + +MYBOOL __EXPORT_TYPE __WINAPI get_variables(lprec *lp, REAL *var); +MYBOOL __EXPORT_TYPE __WINAPI get_ptr_variables(lprec *lp, REAL **var); + +MYBOOL __EXPORT_TYPE __WINAPI get_constraints(lprec *lp, REAL *constr); +MYBOOL __EXPORT_TYPE __WINAPI get_ptr_constraints(lprec *lp, REAL **constr); + +MYBOOL __EXPORT_TYPE __WINAPI get_sensitivity_rhs(lprec *lp, REAL *duals, REAL *dualsfrom, REAL *dualstill); +MYBOOL __EXPORT_TYPE __WINAPI get_ptr_sensitivity_rhs(lprec *lp, REAL **duals, REAL **dualsfrom, REAL **dualstill); + +MYBOOL __EXPORT_TYPE __WINAPI get_sensitivity_obj(lprec *lp, REAL *objfrom, REAL *objtill); +MYBOOL __EXPORT_TYPE __WINAPI get_sensitivity_objex(lprec *lp, REAL *objfrom, REAL *objtill, REAL *objfromvalue, REAL *objtillvalue); +MYBOOL __EXPORT_TYPE __WINAPI get_ptr_sensitivity_obj(lprec *lp, REAL **objfrom, REAL **objtill); +MYBOOL __EXPORT_TYPE __WINAPI get_ptr_sensitivity_objex(lprec *lp, REAL **objfrom, REAL **objtill, REAL **objfromvalue, REAL **objtillvalue); + +void __EXPORT_TYPE __WINAPI set_solutionlimit(lprec *lp, int limit); +int __EXPORT_TYPE __WINAPI get_solutionlimit(lprec *lp); +int __EXPORT_TYPE __WINAPI get_solutioncount(lprec *lp); + +int __EXPORT_TYPE __WINAPI get_Norig_rows(lprec *lp); +int __EXPORT_TYPE __WINAPI get_Nrows(lprec *lp); +int __EXPORT_TYPE __WINAPI get_Lrows(lprec *lp); + +int __EXPORT_TYPE __WINAPI get_Norig_columns(lprec *lp); +int __EXPORT_TYPE __WINAPI get_Ncolumns(lprec *lp); + + +#ifdef __cplusplus +} +#endif + + +/* Forward definitions of functions used internaly by the lp toolkit */ +MYBOOL set_callbacks(lprec *lp); +STATIC int yieldformessages(lprec *lp); +MYBOOL __WINAPI userabort(lprec *lp, int message); +/*char * __VACALL explain(lprec *lp, char *format, ...); +void __VACALL report(lprec *lp, int level, char *format, ...);*/ + +/* Memory management routines */ +STATIC MYBOOL append_rows(lprec *lp, int deltarows); +STATIC MYBOOL append_columns(lprec *lp, int deltacolumns); +STATIC void inc_rows(lprec *lp, int delta); +STATIC void inc_columns(lprec *lp, int delta); +STATIC MYBOOL init_rowcol_names(lprec *lp); +STATIC MYBOOL inc_row_space(lprec *lp, int deltarows); +STATIC MYBOOL inc_col_space(lprec *lp, int deltacols); +STATIC MYBOOL shift_rowcoldata(lprec *lp, int base, int delta, LLrec *usedmap, MYBOOL isrow); +STATIC MYBOOL shift_basis(lprec *lp, int base, int delta, LLrec *usedmap, MYBOOL isrow); +STATIC MYBOOL shift_rowdata(lprec *lp, int base, int delta, LLrec *usedmap); +STATIC MYBOOL shift_coldata(lprec *lp, int base, int delta, LLrec *usedmap); + +/* INLINE */ MYBOOL is_chsign(lprec *lp, int rownr); + +STATIC MYBOOL inc_lag_space(lprec *lp, int deltarows, MYBOOL ignoreMAT); +lprec *make_lag(lprec *server); + +REAL get_rh_upper(lprec *lp, int rownr); +REAL get_rh_lower(lprec *lp, int rownr); +MYBOOL set_rh_upper(lprec *lp, int rownr, REAL value); +MYBOOL set_rh_lower(lprec *lp, int rownr, REAL value); +STATIC int bin_count(lprec *lp, MYBOOL working); +STATIC int MIP_count(lprec *lp); +STATIC int SOS_count(lprec *lp); +STATIC int GUB_count(lprec *lp); +STATIC int identify_GUB(lprec *lp, MYBOOL mark); +STATIC int prepare_GUB(lprec *lp); + +STATIC MYBOOL refactRecent(lprec *lp); +STATIC MYBOOL check_if_less(lprec *lp, REAL x, REAL y, int variable); +STATIC MYBOOL feasiblePhase1(lprec *lp, REAL epsvalue); +STATIC void free_duals(lprec *lp); +STATIC void initialize_solution(lprec *lp, MYBOOL shiftbounds); +STATIC void recompute_solution(lprec *lp, MYBOOL shiftbounds); +STATIC int verify_solution(lprec *lp, MYBOOL reinvert, char *info); +STATIC int check_solution(lprec *lp, int lastcolumn, REAL *solution, + REAL *upbo, REAL *lowbo, REAL tolerance); +/* INLINE */ MYBOOL is_fixedvar(lprec *lp, int variable); +/* INLINE */ MYBOOL is_splitvar(lprec *lp, int colnr); + +void __WINAPI set_action(int *actionvar, int actionmask); +void __WINAPI clear_action(int *actionvar, int actionmask); +MYBOOL __WINAPI is_action(int actionvar, int testmask); + +INLINE MYBOOL is_bb_rule(lprec *lp, int bb_rule); +/* INLINE */ MYBOOL is_bb_mode(lprec *lp, int bb_mask); +/* INLINE */ int get_piv_rule(lprec *lp); +STATIC char *get_str_piv_rule(int rule); +STATIC MYBOOL __WINAPI set_var_priority(lprec *lp); +STATIC int find_sc_bbvar(lprec *lp, int *count); +STATIC int find_sos_bbvar(lprec *lp, int *count, MYBOOL intsos); +STATIC int find_int_bbvar(lprec *lp, int *count, BBrec *BB, MYBOOL *isfeasible); + +/* Solution-related functions */ +STATIC REAL compute_dualslacks(lprec *lp, int target, REAL **dvalues, int **nzdvalues, MYBOOL dosum); +STATIC MYBOOL solution_is_int(lprec *lp, int index, MYBOOL checkfixed); +STATIC MYBOOL bb_better(lprec *lp, int target, int mode); +STATIC void construct_solution(lprec *lp, REAL *target); +STATIC void transfer_solution_var(lprec *lp, int uservar); +STATIC MYBOOL construct_duals(lprec *lp); +STATIC MYBOOL construct_sensitivity_duals(lprec *lp); +STATIC MYBOOL construct_sensitivity_obj(lprec *lp); + +STATIC int add_GUB(lprec *lp, char *name, int priority, int count, int *sosvars); +STATIC basisrec *push_basis(lprec *lp, int *basisvar, MYBOOL *isbasic, MYBOOL *islower); +STATIC MYBOOL compare_basis(lprec *lp); +STATIC MYBOOL restore_basis(lprec *lp); +STATIC MYBOOL pop_basis(lprec *lp, MYBOOL restore); +STATIC MYBOOL is_BasisReady(lprec *lp); +STATIC MYBOOL is_slackbasis(lprec *lp); +STATIC MYBOOL verify_basis(lprec *lp); +STATIC int unload_basis(lprec *lp, MYBOOL restorelast); + +STATIC int perturb_bounds(lprec *lp, BBrec *perturbed, MYBOOL doRows, MYBOOL doCols, MYBOOL includeFIXED); +STATIC MYBOOL validate_bounds(lprec *lp, REAL *upbo, REAL *lowbo); +STATIC MYBOOL impose_bounds(lprec *lp, REAL * upbo, REAL *lowbo); +STATIC int unload_BB(lprec *lp); + +STATIC REAL feasibilityOffset(lprec *lp, MYBOOL isdual); +STATIC MYBOOL isP1extra(lprec *lp); +STATIC REAL get_refactfrequency(lprec *lp, MYBOOL final); +STATIC int findBasicFixedvar(lprec *lp, int afternr, MYBOOL slacksonly); +STATIC MYBOOL isBasisVarFeasible(lprec *lp, REAL tol, int basis_row); +STATIC MYBOOL isPrimalFeasible(lprec *lp, REAL tol, int infeasibles[], REAL *feasibilitygap); +STATIC MYBOOL isDualFeasible(lprec *lp, REAL tol, int *boundflips, int infeasibles[], REAL *feasibilitygap); + +/* Main simplex driver routines */ +STATIC int preprocess(lprec *lp); +STATIC void postprocess(lprec *lp); +STATIC MYBOOL performiteration(lprec *lp, int rownr, int varin, LREAL theta, MYBOOL primal, MYBOOL allowminit, REAL *prow, int *nzprow, REAL *pcol, int *nzpcol, int *boundswaps); +STATIC void transfer_solution_var(lprec *lp, int uservar); +STATIC void transfer_solution(lprec *lp, MYBOOL dofinal); + +/* Scaling utilities */ +STATIC REAL scaled_floor(lprec *lp, int colnr, REAL value, REAL epsscale); +STATIC REAL scaled_ceil(lprec *lp, int colnr, REAL value, REAL epsscale); + +/* Variable mapping utility routines */ +STATIC void varmap_lock(lprec *lp); +STATIC void varmap_clear(lprec *lp); +STATIC MYBOOL varmap_canunlock(lprec *lp); +STATIC void varmap_addconstraint(lprec *lp); +STATIC void varmap_addcolumn(lprec *lp); +STATIC void varmap_delete(lprec *lp, int base, int delta, LLrec *varmap); +STATIC void varmap_compact(lprec *lp, int prev_rows, int prev_cols); +STATIC MYBOOL varmap_validate(lprec *lp, int varno); +STATIC MYBOOL del_varnameex(lprec *lp, hashelem **namelist, hashtable *ht, int varnr, LLrec *varmap); + +/* Pseudo-cost routines (internal) */ +STATIC BBPSrec *init_pseudocost(lprec *lp, int pseudotype); +STATIC void free_pseudocost(lprec *lp); +STATIC REAL get_pseudorange(BBPSrec *pc, int mipvar, int varcode); +STATIC void update_pseudocost(BBPSrec *pc, int mipvar, int varcode, MYBOOL capupper, REAL varsol); +STATIC REAL get_pseudobranchcost(BBPSrec *pc, int mipvar, MYBOOL dofloor); +STATIC REAL get_pseudonodecost(BBPSrec *pc, int mipvar, int vartype, REAL varsol); + +/* Matrix access and equation solving routines */ +STATIC void set_OF_override(lprec *lp, REAL *ofVector); +STATIC void set_OF_p1extra(lprec *lp, REAL p1extra); +STATIC void unset_OF_p1extra(lprec *lp); +MYBOOL modifyOF1(lprec *lp, int index, REAL *ofValue, REAL mult); +REAL __WINAPI get_OF_active(lprec *lp, int varnr, REAL mult); +STATIC MYBOOL is_OF_nz(lprec *lp, int colnr); + +STATIC int get_basisOF(lprec *lp, int coltarget[], REAL crow[], int colno[]); +int __WINAPI get_basiscolumn(lprec *lp, int j, int rn[], double bj[]); +int __WINAPI obtain_column(lprec *lp, int varin, REAL *pcol, int *nzlist, int *maxabs); +STATIC int compute_theta(lprec *lp, int rownr, LREAL *theta, int isupbound, REAL HarrisScalar, MYBOOL primal); + +/* Pivot utility routines */ +STATIC int findBasisPos(lprec *lp, int notint, int *var_basic); +STATIC MYBOOL check_degeneracy(lprec *lp, REAL *pcol, int *degencount); + +typedef int (__WINAPI read_modeldata_func)(void *userhandle, char *buf, int max_size); +typedef int (__WINAPI write_modeldata_func)(void *userhandle, char *buf); +MYBOOL __WINAPI MPS_readex(lprec **newlp, void *userhandle, read_modeldata_func read_modeldata, int typeMPS, int verbose); +#if defined develop +lprec __EXPORT_TYPE * __WINAPI read_lpex(void *userhandle, read_modeldata_func read_modeldata, int verbose, char *lp_name); +MYBOOL __EXPORT_TYPE __WINAPI write_lpex(lprec *lp, void *userhandle, write_modeldata_func write_modeldata); + +lprec __EXPORT_TYPE * __WINAPI read_mpsex(void *userhandle, read_modeldata_func read_modeldata, int verbose); +lprec __EXPORT_TYPE * __WINAPI read_freempsex(void *userhandle, read_modeldata_func read_modeldata, int verbose); + +MYBOOL MPS_writefileex(lprec *lp, int typeMPS, void *userhandle, write_modeldata_func write_modeldata); +#endif + +#endif /* HEADER_lp_lib */ diff --git a/include/lp_matrix.h b/include/lp_matrix.h new file mode 100644 index 0000000..a1cf9b6 --- /dev/null +++ b/include/lp_matrix.h @@ -0,0 +1,257 @@ +#ifndef HEADER_lp_matrix +#define HEADER_lp_matrix + +#include "lp_types.h" +#include "lp_utils.h" + + +/* Sparse matrix element (ordered columnwise) */ +typedef struct _MATitem +{ + int rownr; + int colnr; + REAL value; +} MATitem; + +/* Constants for matrix product rounding options */ +#define MAT_ROUNDNONE 0 +#define MAT_ROUNDABS 1 +#define MAT_ROUNDREL 2 +#define MAT_ROUNDABSREL (MAT_ROUNDABS + MAT_ROUNDREL) +#define MAT_ROUNDRC 4 +#define MAT_ROUNDRCMIN 1.0 /* lp->epspivot */ +#if 1 + #define MAT_ROUNDDEFAULT MAT_ROUNDREL /* Typically increases performance */ +#else + #define MAT_ROUNDDEFAULT MAT_ROUNDABS /* Probably gives more precision */ +#endif + +/* Compiler option development features */ +/*#define DebugInv*/ /* Report array values at factorization/inversion */ +#define NoLoopUnroll /* Do not do loop unrolling */ +#define DirectArrayOF /* Reference lp->obj[] array instead of function call */ + + +/* Matrix column access macros to be able to easily change storage model */ +#define CAM_Record 0 +#define CAM_Vector 1 +#if 0 + #define MatrixColAccess CAM_Record +#else + #define MatrixColAccess CAM_Vector +#endif + +#if MatrixColAccess==CAM_Record +#define SET_MAT_ijA(item,i,j,A) mat->col_mat[item].rownr = i; \ + mat->col_mat[item].colnr = j; \ + mat->col_mat[item].value = A +#define COL_MAT_COLNR(item) (mat->col_mat[item].colnr) +#define COL_MAT_ROWNR(item) (mat->col_mat[item].rownr) +#define COL_MAT_VALUE(item) (mat->col_mat[item].value) +#define COL_MAT_COPY(left,right) mat->col_mat[left] = mat->col_mat[right] +#define COL_MAT_MOVE(to,from,rec) MEMMOVE(&(mat->col_mat[to]),&(mat->col_mat[from]),rec) +#define COL_MAT2_COLNR(item) (mat2->col_mat[item].colnr) +#define COL_MAT2_ROWNR(item) (mat2->col_mat[item].rownr) +#define COL_MAT2_VALUE(item) (mat2->col_mat[item].value) +#define matRowColStep (sizeof(MATitem)/sizeof(int)) +#define matValueStep (sizeof(MATitem)/sizeof(REAL)) + +#else /* if MatrixColAccess==CAM_Vector */ +#define SET_MAT_ijA(item,i,j,A) mat->col_mat_rownr[item] = i; \ + mat->col_mat_colnr[item] = j; \ + mat->col_mat_value[item] = A +#define COL_MAT_COLNR(item) (mat->col_mat_colnr[item]) +#define COL_MAT_ROWNR(item) (mat->col_mat_rownr[item]) +#define COL_MAT_VALUE(item) (mat->col_mat_value[item]) +#define COL_MAT_COPY(left,right) COL_MAT_COLNR(left) = COL_MAT_COLNR(right); \ + COL_MAT_ROWNR(left) = COL_MAT_ROWNR(right); \ + COL_MAT_VALUE(left) = COL_MAT_VALUE(right) +#define COL_MAT_MOVE(to,from,rec) MEMMOVE(&COL_MAT_COLNR(to),&COL_MAT_COLNR(from),rec); \ + MEMMOVE(&COL_MAT_ROWNR(to),&COL_MAT_ROWNR(from),rec); \ + MEMMOVE(&COL_MAT_VALUE(to),&COL_MAT_VALUE(from),rec) +#define COL_MAT2_COLNR(item) (mat2->col_mat_colnr[item]) +#define COL_MAT2_ROWNR(item) (mat2->col_mat_rownr[item]) +#define COL_MAT2_VALUE(item) (mat2->col_mat_value[item]) +#define matRowColStep 1 +#define matValueStep 1 + +#endif + + +/* Matrix row access macros to be able to easily change storage model */ +#define RAM_Index 0 +#define RAM_FullCopy 1 +#define MatrixRowAccess RAM_Index + +#if MatrixRowAccess==RAM_Index +#define ROW_MAT_COLNR(item) COL_MAT_COLNR(mat->row_mat[item]) +#define ROW_MAT_ROWNR(item) COL_MAT_ROWNR(mat->row_mat[item]) +#define ROW_MAT_VALUE(item) COL_MAT_VALUE(mat->row_mat[item]) + +#elif MatrixColAccess==CAM_Record +#define ROW_MAT_COLNR(item) (mat->row_mat[item].colnr) +#define ROW_MAT_ROWNR(item) (mat->row_mat[item].rownr) +#define ROW_MAT_VALUE(item) (mat->row_mat[item].value) + +#else /* if MatrixColAccess==CAM_Vector */ +#define ROW_MAT_COLNR(item) (mat->row_mat_colnr[item]) +#define ROW_MAT_ROWNR(item) (mat->row_mat_rownr[item]) +#define ROW_MAT_VALUE(item) (mat->row_mat_value[item]) + +#endif + + +typedef struct _MATrec +{ + /* Owner reference */ + lprec *lp; + + /* Active dimensions */ + int rows; + int columns; + + /* Allocated memory */ + int rows_alloc; + int columns_alloc; + int mat_alloc; /* The allocated size for matrix sized structures */ + + /* Sparse problem matrix storage */ +#if MatrixColAccess==CAM_Record + MATitem *col_mat; /* mat_alloc : The sparse data storage */ +#else /*MatrixColAccess==CAM_Vector*/ + int *col_mat_colnr; + int *col_mat_rownr; + REAL *col_mat_value; +#endif + int *col_end; /* columns_alloc+1 : col_end[i] is the index of the + first element after column i; column[i] is stored + in elements col_end[i-1] to col_end[i]-1 */ + int *col_tag; /* user-definable tag associated with each column */ + +#if MatrixRowAccess==RAM_Index + int *row_mat; /* mat_alloc : From index 0, row_mat contains the + row-ordered index of the elements of col_mat */ +#elif MatrixColAccess==CAM_Record + MATitem *row_mat; /* mat_alloc : From index 0, row_mat contains the + row-ordered copy of the elements in col_mat */ +#else /*if MatrixColAccess==CAM_Vector*/ + int *row_mat_colnr; + int *row_mat_rownr; + REAL *row_mat_value; +#endif + int *row_end; /* rows_alloc+1 : row_end[i] is the index of the + first element in row_mat after row i */ + int *row_tag; /* user-definable tag associated with each row */ + + REAL *colmax; /* Array of maximum values of each column */ + REAL *rowmax; /* Array of maximum values of each row */ + + REAL epsvalue; /* Zero element rejection threshold */ + REAL infnorm; /* The largest absolute value in the matrix */ + REAL dynrange; + MYBOOL row_end_valid; /* TRUE if row_end & row_mat are valid */ + MYBOOL is_roworder; /* TRUE if the current (temporary) matrix order is row-wise */ + +} MATrec; + +typedef struct _DeltaVrec +{ + lprec *lp; + int activelevel; + MATrec *tracker; +} DeltaVrec; + + +#ifdef __cplusplus +__EXTERN_C { +#endif + +/* Sparse matrix routines */ +STATIC MATrec *mat_create(lprec *lp, int rows, int columns, REAL epsvalue); +STATIC MYBOOL mat_memopt(MATrec *mat, int rowextra, int colextra, int nzextra); +STATIC void mat_free(MATrec **matrix); +STATIC MYBOOL inc_matrow_space(MATrec *mat, int deltarows); +STATIC int mat_mapreplace(MATrec *mat, LLrec *rowmap, LLrec *colmap, MATrec *insmat); +STATIC int mat_matinsert(MATrec *mat, MATrec *insmat); +STATIC int mat_zerocompact(MATrec *mat); +STATIC int mat_rowcompact(MATrec *mat, MYBOOL dozeros); +STATIC int mat_colcompact(MATrec *mat, int prev_rows, int prev_cols); +STATIC MYBOOL inc_matcol_space(MATrec *mat, int deltacols); +STATIC MYBOOL inc_mat_space(MATrec *mat, int mindelta); +STATIC int mat_shiftrows(MATrec *mat, int *bbase, int delta, LLrec *varmap); +STATIC int mat_shiftcols(MATrec *mat, int *bbase, int delta, LLrec *varmap); +STATIC MATrec *mat_extractmat(MATrec *mat, LLrec *rowmap, LLrec *colmap, MYBOOL negated); +STATIC int mat_appendrow(MATrec *mat, int count, REAL *row, int *colno, REAL mult, MYBOOL checkrowmode); +STATIC int mat_appendcol(MATrec *mat, int count, REAL *column, int *rowno, REAL mult, MYBOOL checkrowmode); +MYBOOL mat_get_data(lprec *lp, int matindex, MYBOOL isrow, int **rownr, int **colnr, REAL **value); +MYBOOL mat_set_rowmap(MATrec *mat, int row_mat_index, int rownr, int colnr, int col_mat_index); +STATIC MYBOOL mat_indexrange(MATrec *mat, int index, MYBOOL isrow, int *startpos, int *endpos); +STATIC MYBOOL mat_validate(MATrec *mat); +STATIC MYBOOL mat_equalRows(MATrec *mat, int baserow, int comprow); +STATIC int mat_findelm(MATrec *mat, int row, int column); +STATIC int mat_findins(MATrec *mat, int row, int column, int *insertpos, MYBOOL validate); +STATIC void mat_multcol(MATrec *mat, int col_nr, REAL mult); +STATIC REAL mat_getitem(MATrec *mat, int row, int column); +STATIC MYBOOL mat_setitem(MATrec *mat, int row, int column, REAL value); +STATIC MYBOOL mat_additem(MATrec *mat, int row, int column, REAL delta); +STATIC MYBOOL mat_setvalue(MATrec *mat, int Row, int Column, REAL Value, MYBOOL doscale); +STATIC int mat_nonzeros(MATrec *mat); +STATIC int mat_collength(MATrec *mat, int colnr); +STATIC int mat_rowlength(MATrec *mat, int rownr); +STATIC void mat_multrow(MATrec *mat, int row_nr, REAL mult); +STATIC void mat_multadd(MATrec *mat, REAL *lhsvector, int varnr, REAL mult); +STATIC MYBOOL mat_setrow(MATrec *mat, int rowno, int count, REAL *row, int *colno, MYBOOL doscale, MYBOOL checkrowmode); +STATIC MYBOOL mat_setcol(MATrec *mat, int colno, int count, REAL *column, int *rowno, MYBOOL doscale, MYBOOL checkrowmode); +STATIC MYBOOL mat_mergemat(MATrec *target, MATrec *source, MYBOOL usecolmap); +STATIC int mat_checkcounts(MATrec *mat, int *rownum, int *colnum, MYBOOL freeonexit); +STATIC int mat_expandcolumn(MATrec *mat, int colnr, REAL *column, int *nzlist, MYBOOL signedA); +STATIC MYBOOL mat_computemax(MATrec *mat); +STATIC MYBOOL mat_transpose(MATrec *mat); + +/* Refactorization and recomputation routine */ +MYBOOL __WINAPI invert(lprec *lp, MYBOOL shiftbounds, MYBOOL final); + +/* Vector compression and expansion routines */ +STATIC MYBOOL vec_compress(REAL *densevector, int startpos, int endpos, REAL epsilon, REAL *nzvector, int *nzindex); +STATIC MYBOOL vec_expand(REAL *nzvector, int *nzindex, REAL *densevector, int startpos, int endpos); + +/* Sparse matrix products */ +STATIC MYBOOL get_colIndexA(lprec *lp, int varset, int *colindex, MYBOOL append); +STATIC int prod_Ax(lprec *lp, int *coltarget, REAL *input, int *nzinput, REAL roundzero, REAL ofscalar, REAL *output, int *nzoutput, int roundmode); +STATIC int prod_xA(lprec *lp, int *coltarget, REAL *input, int *nzinput, REAL roundzero, REAL ofscalar, REAL *output, int *nzoutput, int roundmode); +STATIC MYBOOL prod_xA2(lprec *lp, int *coltarget, REAL *prow, REAL proundzero, int *pnzprow, + REAL *drow, REAL droundzero, int *dnzdrow, REAL ofscalar, int roundmode); + +/* Equation solution */ +STATIC MYBOOL fimprove(lprec *lp, REAL *pcol, int *nzidx, REAL roundzero); +STATIC void ftran(lprec *lp, REAL *rhsvector, int *nzidx, REAL roundzero); +STATIC MYBOOL bimprove(lprec *lp, REAL *rhsvector, int *nzidx, REAL roundzero); +STATIC void btran(lprec *lp, REAL *rhsvector, int *nzidx, REAL roundzero); + +/* Combined equation solution and matrix product for simplex operations */ +STATIC MYBOOL fsolve(lprec *lp, int varin, REAL *pcol, int *nzidx, REAL roundzero, REAL ofscalar, MYBOOL prepareupdate); +STATIC MYBOOL bsolve(lprec *lp, int row_nr, REAL *rhsvector, int *nzidx, REAL roundzero, REAL ofscalar); +STATIC void bsolve_xA2(lprec *lp, int* coltarget, + int row_nr1, REAL *vector1, REAL roundzero1, int *nzvector1, + int row_nr2, REAL *vector2, REAL roundzero2, int *nzvector2, int roundmode); + +/* Change-tracking routines (primarily for B&B and presolve) */ +STATIC DeltaVrec *createUndoLadder(lprec *lp, int levelitems, int maxlevels); +STATIC int incrementUndoLadder(DeltaVrec *DV); +STATIC MYBOOL modifyUndoLadder(DeltaVrec *DV, int itemno, REAL target[], REAL newvalue); +STATIC int countsUndoLadder(DeltaVrec *DV); +STATIC int restoreUndoLadder(DeltaVrec *DV, REAL target[]); +STATIC int decrementUndoLadder(DeltaVrec *DV); +STATIC MYBOOL freeUndoLadder(DeltaVrec **DV); + +/* Specialized presolve undo functions */ +STATIC MYBOOL appendUndoPresolve(lprec *lp, MYBOOL isprimal, REAL beta, int colnrDep); +STATIC MYBOOL addUndoPresolve(lprec *lp, MYBOOL isprimal, int colnrElim, REAL alpha, REAL beta, int colnrDep); + + +#ifdef __cplusplus +} +#endif + +#endif /* HEADER_lp_matrix */ + diff --git a/include/lp_mipbb.h b/include/lp_mipbb.h new file mode 100644 index 0000000..db1947c --- /dev/null +++ b/include/lp_mipbb.h @@ -0,0 +1,64 @@ +#ifndef HEADER_lp_mipbb +#define HEADER_lp_mipbb + +#include "lp_types.h" +#include "lp_utils.h" + + +/* Bounds storage for B&B routines */ +typedef struct _BBrec +{ + struct _BBrec *parent; + struct _BBrec *child; + lprec *lp; + int varno; + int vartype; + int lastvarcus; /* Count of non-int variables of the previous branch */ + int lastrcf; + int nodesleft; + int nodessolved; + int nodestatus; + REAL noderesult; + REAL lastsolution; /* Optimal solution of the previous branch */ + REAL sc_bound; + REAL *upbo, *lowbo; + REAL UPbound, LObound; + int UBtrack, LBtrack; /* Signals that incoming bounds were changed */ + MYBOOL contentmode; /* Flag indicating if we "own" the bound vectors */ + MYBOOL sc_canset; + MYBOOL isSOS; + MYBOOL isGUB; + int *varmanaged; /* Extended list of variables managed by this B&B level */ + MYBOOL isfloor; /* State variable indicating the active B&B bound */ + MYBOOL UBzerobased; /* State variable indicating if bounds have been rebased */ +} BBrec; + +#ifdef __cplusplus +extern "C" { +#endif + +STATIC BBrec *create_BB(lprec *lp, BBrec *parentBB, MYBOOL dofullcopy); +STATIC BBrec *push_BB(lprec *lp, BBrec *parentBB, int varno, int vartype, int varcus); +STATIC MYBOOL initbranches_BB(BBrec *BB); +STATIC MYBOOL fillbranches_BB(BBrec *BB); +STATIC MYBOOL nextbranch_BB(BBrec *BB); +STATIC MYBOOL strongbranch_BB(lprec *lp, BBrec *BB, int varno, int vartype, int varcus); +STATIC MYBOOL initcuts_BB(lprec *lp); +STATIC int updatecuts_BB(lprec *lp); +STATIC MYBOOL freecuts_BB(lprec *lp); +STATIC BBrec *findself_BB(BBrec *BB); +STATIC int solve_LP(lprec *lp, BBrec *BB); +STATIC int rcfbound_BB(BBrec *BB, int varno, MYBOOL isINT, REAL *newbound, MYBOOL *isfeasible); +STATIC MYBOOL findnode_BB(BBrec *BB, int *varno, int *vartype, int *varcus); +STATIC int solve_BB(BBrec *BB); +STATIC MYBOOL free_BB(BBrec **BB); +STATIC BBrec *pop_BB(BBrec *BB); + +STATIC int run_BB(lprec *lp); + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_lp_mipbb */ + diff --git a/include/lp_presolve.h b/include/lp_presolve.h new file mode 100644 index 0000000..f59406b --- /dev/null +++ b/include/lp_presolve.h @@ -0,0 +1,126 @@ +#ifndef HEADER_lp_presolve +#define HEADER_lp_presolve + +#include "lp_types.h" +#include "lp_matrix.h" + +/* -------------------------------------------------------------------------------------------- */ +/* Defines for various presolve options */ +/* -------------------------------------------------------------------------------------------- */ + +#define MAX_PSMERGELOOPS 2 /* Max loops to merge compatible constraints */ +#define MAX_PSLINDEPLOOPS 1 /* Max loops to detect linearly dependendent constraints */ +#define MAX_PSBOUNDTIGHTENLOOPS 5 /* Maximumn number of loops to allow bound tightenings */ +#define MIN_SOS1LENGTH 4 /* Minimum length of a constraint for conversion to SOS1 */ +#if 1 + #define PRESOLVE_EPSVALUE (0.1*lp->epsprimal) +#else + #define PRESOLVE_EPSVALUE lp->epsvalue +#endif +#define PRESOLVE_EPSPIVOT 1.0e-3 /* Looses robustness at values smaller than ~1.0e-3 */ +#define PRESOLVE_BOUNDSLACK 10 /* Extra error recovery/tolerance margin */ + +#define DoPresolveRounding /* Use absolute and directed rounding (disable at own risk) */ +/*#define DoPresolveRelativeTest*/ + +/*#define PresolveForceUpdateMax*/ + +/*#define DualFeasibilityLogicEQ2*/ /* Add low-order feasibility/accuracy logic to elimEQ2 */ +#define DivisorIntegralityLogicEQ2 /* Always prefer integer divisors */ +#define FindImpliedEqualities /* Detect equalities (default is enabled) */ +#define Eq2Reldiff + +/*#define SavePresolveEliminated */ /* Enable to activate storage of eliminated matrix data */ +/*#define UseDualPresolve */ /* Enable to use full dual information for presolve */ + + +typedef struct _psrec +{ + LLrec *varmap; + int **next; + int *empty; + int *plucount; + int *negcount; + int *pluneg; + int *infcount; + REAL *plulower; + REAL *neglower; + REAL *pluupper; + REAL *negupper; + int allocsize; +} psrec; + +typedef struct _presolverec +{ + psrec *rows; + psrec *cols; + LLrec *EQmap; + LLrec *LTmap; + LLrec *INTmap; + REAL *pv_upbo; + REAL *pv_lobo; + REAL *dv_upbo; + REAL *dv_lobo; + lprec *lp; + REAL epsvalue; + REAL epspivot; + int innerloops; + int middleloops; + int outerloops; + int nzdeleted; + MYBOOL forceupdate; +} presolverec; + +#ifdef __cplusplus +extern "C" { +#endif + +/* Put function headers here */ + +STATIC MYBOOL presolve_createUndo(lprec *lp); +STATIC MYBOOL presolve_rebuildUndo(lprec *lp, MYBOOL isprimal); +STATIC MYBOOL inc_presolve_space(lprec *lp, int delta, MYBOOL isrows); +STATIC MYBOOL presolve_setOrig(lprec *lp, int orig_rows, int orig_cols); +STATIC MYBOOL presolve_colfix(presolverec *psdata, int colnr, REAL newvalue, MYBOOL remove, int *tally); +STATIC MYBOOL presolve_fillUndo(lprec *lp, int orig_rows, int orig_cols, MYBOOL setOrig); +STATIC MYBOOL presolve_freeUndo(lprec *lp); + +STATIC MYBOOL presolve_updatesums(presolverec *psdata); + +INLINE int presolve_nextrow(presolverec *psdata, int colnr, int *previtem); +INLINE int presolve_nextcol(presolverec *psdata, int rownr, int *previtem); + +STATIC presolverec *presolve_init(lprec *lp); +STATIC void presolve_free(presolverec **psdata); +STATIC int presolve_shrink(presolverec *psdata, int *nConRemove, int *nVarRemove); +STATIC void presolve_rowremove(presolverec *psdata, int rownr, MYBOOL allowcoldelete); +STATIC int presolve_colremove(presolverec *psdata, int colnr, MYBOOL allowrowdelete); + +STATIC MYBOOL presolve_colfixdual(presolverec *psdata, int colnr, REAL *fixValue, int *status); + +INLINE int presolve_rowlength(presolverec *psdata, int rownr) +{ + int *items = psdata->rows->next[rownr]; + + if(items == NULL) + return( 0 ); + else + return( items[0] ); +} +INLINE int presolve_collength(presolverec *psdata, int colnr) +{ + int *items = psdata->cols->next[colnr]; + if(items == NULL) + return( 0 ); + else + return( items[0] ); +} + +STATIC int presolve(lprec *lp); +STATIC MYBOOL postsolve(lprec *lp, int status); + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_lp_presolve */ diff --git a/include/lp_price.h b/include/lp_price.h new file mode 100644 index 0000000..9e8d8bc --- /dev/null +++ b/include/lp_price.h @@ -0,0 +1,99 @@ +#ifndef HEADER_lp_price +#define HEADER_lp_price + +/* Local defines */ +/* ------------------------------------------------------------------------- */ +#define UseSortOnBound_Improve +/*#define UseSortOnBound_Substitute*/ + +#if 0 /* Stricter feasibility-preserving tolerance; use w/ *_UseRejectionList */ + #define UseRelativeFeasibility /* Use machine-precision and A-scale data */ +#endif +#if 0 /* Stricter pivot-selection criteria; use w/ *UseRejectionList */ + #define UseRelativePivot_Primal /* In rowprim based on A-scale data */ + #define UseRelativePivot_Dual /* In coldual based on A-scale data */ +#endif + + +/* Include required library headers */ +/* ------------------------------------------------------------------------- */ +#include "lp_types.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +/* Comparison and validity routines */ +int CMP_CALLMODEL compareImprovementVar(const pricerec *current, const pricerec *candidate); +int CMP_CALLMODEL compareSubstitutionVar(const pricerec *current, const pricerec *candidate); +int CMP_CALLMODEL compareBoundFlipVar(const pricerec *current, const pricerec *candidate); +STATIC int addCandidateVar(pricerec *candidate, multirec *multi, findCompare_func findCompare, MYBOOL allowSortedExpand); +STATIC MYBOOL collectMinorVar(pricerec *candidate, multirec *longsteps, MYBOOL isphase2, MYBOOL isbatch); +STATIC MYBOOL validImprovementVar(pricerec *candidate); +STATIC MYBOOL validSubstitutionVar(pricerec *candidate); + +/* Row+column selection routines */ +STATIC MYBOOL findImprovementVar(pricerec *current, pricerec *candidate, MYBOOL collectMP, int *candidatecount); +STATIC MYBOOL findSubstitutionVar(pricerec *current, pricerec *candidate, int *candidatecount); +INLINE REAL normalizeEdge(lprec *lp, int item, REAL edge, MYBOOL isdual); +STATIC void makePriceLoop(lprec *lp, int *start, int *end, int *delta); + +/* Computation of reduced costs */ +STATIC void update_reducedcosts(lprec *lp, MYBOOL isdual, int leave_nr, int enter_nr, REAL *prow, REAL *drow); +STATIC void compute_reducedcosts(lprec *lp, MYBOOL isdual, int row_nr, int *coltarget, MYBOOL dosolve, + REAL *prow, int *nzprow, + REAL *drow, int *nzdrow, + int roundmode); + +/* Leaving variable selection and entering column pricing loops */ +STATIC int find_rowReplacement(lprec *lp, int rownr, REAL *prow, int *nzprow); +STATIC int colprim(lprec *lp, REAL *drow, int *nzdrow, + MYBOOL skipupdate, int partialloop, int *candidatecount, MYBOOL updateinfeas, REAL *xviol); +STATIC int rowprim(lprec *lp, int colnr, LREAL *theta, REAL *pcol, int *nzpcol, MYBOOL forceoutEQ, REAL *xviol); +STATIC int rowdual(lprec *lp, REAL *rhvec, MYBOOL forceoutEQ, MYBOOL updateinfeas, REAL *xviol); +STATIC int coldual(lprec *lp, int row_nr, + REAL *prow, int *nzprow, REAL *drow, int *nzdrow, + MYBOOL dualphase1, MYBOOL skipupdate, + int *candidatecount, REAL *xviol); + +/* Partial pricing management routines */ +STATIC partialrec *partial_createBlocks(lprec *lp, MYBOOL isrow); +STATIC int partial_countBlocks(lprec *lp, MYBOOL isrow); +STATIC int partial_activeBlocks(lprec *lp, MYBOOL isrow); +STATIC void partial_freeBlocks(partialrec **blockdata); + +/* Partial pricing utility routines */ +STATIC int partial_findBlocks(lprec *lp, MYBOOL autodefine, MYBOOL isrow); +STATIC int partial_blockStart(lprec *lp, MYBOOL isrow); +STATIC int partial_blockEnd(lprec *lp, MYBOOL isrow); +STATIC int partial_blockNextPos(lprec *lp, int block, MYBOOL isrow); + +STATIC MYBOOL partial_blockStep(lprec *lp, MYBOOL isrow); +STATIC MYBOOL partial_isVarActive(lprec *lp, int varno, MYBOOL isrow); + +/* Multiple pricing / dual long step management routines */ +STATIC multirec *multi_create(lprec *lp, MYBOOL truncinf); +STATIC MYBOOL multi_resize(multirec *multi, int blocksize, int blockdiv, MYBOOL doVlist, MYBOOL doIset); +STATIC int multi_restart(multirec *multi); +STATIC int multi_size(multirec *multi); +STATIC int multi_used(multirec *multi); +STATIC MYBOOL multi_truncatingvar(multirec *multi, int varnr); +STATIC MYBOOL multi_mustupdate(multirec *multi); +STATIC void multi_valueInit(multirec *multi, REAL step_base, REAL obj_base); +STATIC REAL *multi_valueList(multirec *multi); +STATIC int *multi_indexSet(multirec *multi, MYBOOL regenerate); +STATIC int multi_getvar(multirec *multi, int item); +STATIC MYBOOL multi_recompute(multirec *multi, int index, MYBOOL isphase2, MYBOOL fullupdate); +STATIC MYBOOL multi_removevar(multirec *multi, int varnr); +STATIC int multi_enteringvar(multirec *multi, pricerec *current, int priority); +STATIC REAL multi_enteringtheta(multirec *multi); +STATIC void multi_free(multirec **multi); +STATIC int multi_populateSet(multirec *multi, int **list, int excludenr); + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_lp_price */ + diff --git a/include/lp_pricePSE.h b/include/lp_pricePSE.h new file mode 100644 index 0000000..1c8c2f8 --- /dev/null +++ b/include/lp_pricePSE.h @@ -0,0 +1,28 @@ +#ifndef HEADER_lp_pricePSE +#define HEADER_lp_pricePSE + +#include "lp_types.h" + +#define ApplySteepestEdgeMinimum + +#ifdef __cplusplus +extern "C" { +#endif + +/* Price norm management routines */ +STATIC MYBOOL initPricer(lprec *lp); +INLINE MYBOOL applyPricer(lprec *lp); +STATIC void simplexPricer(lprec *lp, MYBOOL isdual); +STATIC void freePricer(lprec *lp); +STATIC MYBOOL resizePricer(lprec *lp); +STATIC REAL getPricer(lprec *lp, int item, MYBOOL isdual); +STATIC MYBOOL restartPricer(lprec *lp, MYBOOL isdual); +STATIC MYBOOL updatePricer(lprec *lp, int rownr, int colnr, REAL *pcol, REAL *prow, int *nzprow); +STATIC MYBOOL verifyPricer(lprec *lp); + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_lp_pricePSE */ + diff --git a/include/lp_report.h b/include/lp_report.h new file mode 100644 index 0000000..a8567fe --- /dev/null +++ b/include/lp_report.h @@ -0,0 +1,42 @@ +#ifndef HEADER_lp_report +#define HEADER_lp_report + +#ifdef __cplusplus +extern "C" { +#endif + +/* General information functions */ +char * __VACALL explain(lprec *lp, char *format, ...); +void __VACALL report(lprec *lp, int level, char *format, ...); + +/* Prototypes for debugging and general data dumps */ +void debug_print(lprec *lp, char *format, ...); +void debug_print_solution(lprec *lp); +void debug_print_bounds(lprec *lp, REAL *upbo, REAL *lowbo); +void blockWriteLREAL(FILE *output, char *label, LREAL *vector, int first, int last); +void blockWriteAMAT(FILE *output, const char *label, lprec* lp, int first, int last); +void blockWriteBMAT(FILE *output, const char *label, lprec* lp, int first, int last); + + +/* Model reporting headers */ +void REPORT_objective(lprec *lp); +void REPORT_solution(lprec *lp, int columns); +void REPORT_constraints(lprec *lp, int columns); +void REPORT_duals(lprec *lp); +void REPORT_extended(lprec *lp); + +/* Other rarely used, but sometimes extremely useful reports */ +void REPORT_constraintinfo(lprec *lp, char *datainfo); +void REPORT_modelinfo(lprec *lp, MYBOOL doName, char *datainfo); +void REPORT_lp(lprec *lp); +MYBOOL REPORT_tableau(lprec *lp); +void REPORT_scales(lprec *lp); +MYBOOL REPORT_debugdump(lprec *lp, char *filename, MYBOOL livedata); +MYBOOL REPORT_mat_mmsave(lprec *lp, char *filename, int *colndx, MYBOOL includeOF, char *infotext); + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_lp_report */ + diff --git a/include/lp_rlp.h b/include/lp_rlp.h new file mode 100644 index 0000000..b9cffb2 --- /dev/null +++ b/include/lp_rlp.h @@ -0,0 +1,1901 @@ +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define lp_yyconst const +#else +#define lp_yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN lp_yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((lp_yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE lp_yyrestart( lp_yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct lp_yy_buffer_state *YY_BUFFER_STATE; + +extern int lp_yyleng; +extern FILE *lp_yyin, *lp_yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * lp_yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the lp_yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define lp_yyless(n) \ + do \ + { \ + /* Undo effects of setting up lp_yytext. */ \ + *lp_yy_cp = lp_yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + lp_yy_c_buf_p = lp_yy_cp = lp_yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up lp_yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) lp_yyunput( c, lp_yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int lp_yy_size_t; + + +struct lp_yy_buffer_state + { + FILE *lp_yy_input_file; + + char *lp_yy_ch_buf; /* input buffer */ + char *lp_yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + lp_yy_size_t lp_yy_buf_size; + + /* Number of characters read into lp_yy_ch_buf, not including EOB + * characters. + */ + int lp_yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int lp_yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int lp_yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int lp_yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int lp_yy_fill_buffer; + + int lp_yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via lp_yyrestart()), so that the user can continue scanning by + * just pointing lp_yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE lp_yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER lp_yy_current_buffer + + +/* lp_yy_hold_char holds the character lost when lp_yytext is formed. */ +static char lp_yy_hold_char; + +static int lp_yy_n_chars; /* number of characters read into lp_yy_ch_buf */ + + +int lp_yyleng; + +/* Points to current character in buffer. */ +static char *lp_yy_c_buf_p = (char *) 0; +static int lp_yy_init = 1; /* whether we need to initialize */ +static int lp_yy_start = 0; /* start state number */ + +/* Flag which is used to allow lp_yywrap()'s to do buffer switches + * instead of setting up a fresh lp_yyin. A bit of a hack ... + */ +static int lp_yy_did_buffer_switch_on_eof; + +void lp_yyrestart YY_PROTO(( FILE *input_file )); + +void lp_yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void lp_yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE lp_yy_create_buffer YY_PROTO(( FILE *file, int size )); +void lp_yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void lp_yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void lp_yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER lp_yy_flush_buffer( lp_yy_current_buffer ) + +YY_BUFFER_STATE lp_yy_scan_buffer YY_PROTO(( char *base, lp_yy_size_t size )); +YY_BUFFER_STATE lp_yy_scan_string YY_PROTO(( lp_yyconst char *lp_yy_str )); +YY_BUFFER_STATE lp_yy_scan_bytes YY_PROTO(( lp_yyconst char *bytes, int len )); + +static void *lp_yy_flex_alloc YY_PROTO(( lp_yy_size_t )); +static void *lp_yy_flex_realloc YY_PROTO(( void *, lp_yy_size_t )); +static void lp_yy_flex_free YY_PROTO(( void * )); + +#define lp_yy_new_buffer lp_yy_create_buffer + +#define lp_yy_set_interactive(is_interactive) \ + { \ + if ( ! lp_yy_current_buffer ) \ + lp_yy_current_buffer = lp_yy_create_buffer( lp_yyin, YY_BUF_SIZE ); \ + lp_yy_current_buffer->lp_yy_is_interactive = is_interactive; \ + } + +#define lp_yy_set_bol(at_bol) \ + { \ + if ( ! lp_yy_current_buffer ) \ + lp_yy_current_buffer = lp_yy_create_buffer( lp_yyin, YY_BUF_SIZE ); \ + lp_yy_current_buffer->lp_yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (lp_yy_current_buffer->lp_yy_at_bol) + + +#define YY_USES_REJECT +typedef unsigned char YY_CHAR; +FILE *lp_yyin = (FILE *) 0, *lp_yyout = (FILE *) 0; +typedef int lp_yy_state_type; +#define YY_FLEX_LEX_COMPAT +extern int lp_yylineno; +int lp_yylineno = 1; +extern char lp_yytext[]; + + +static lp_yy_state_type lp_yy_get_previous_state YY_PROTO(( void )); +static lp_yy_state_type lp_yy_try_NUL_trans YY_PROTO(( lp_yy_state_type current_state )); +static int lp_yy_get_next_buffer YY_PROTO(( void )); +static void lp_yy_fatal_error YY_PROTO(( lp_yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up lp_yytext. + */ +#define YY_DO_BEFORE_ACTION \ + lp_yytext_ptr = lp_yy_bp; \ + lp_yyleng = (int) (lp_yy_cp - lp_yy_bp); \ + lp_yy_hold_char = *lp_yy_cp; \ + *lp_yy_cp = '\0'; \ + if ( lp_yyleng + lp_yy_more_offset >= YYLMAX ) \ + YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \ + lp_yy_flex_strncpy( &lp_yytext[lp_yy_more_offset], lp_yytext_ptr, lp_yyleng + 1 ); \ + lp_yyleng += lp_yy_more_offset; \ + lp_yy_prev_more_offset = lp_yy_more_offset; \ + lp_yy_more_offset = 0; \ + lp_yy_c_buf_p = lp_yy_cp; + +#define YY_NUM_RULES 30 +#define YY_END_OF_BUFFER 31 +static lp_yyconst short int lp_yy_acclist[149] = + { 0, + 26, 26, 31, 29, 30, 10, 17, 29, 30, 10, + 17, 30, 25, 29, 30, 17, 29, 30, 11, 29, + 30, 29, 30, 29, 30, 14, 15, 29, 30, 24, + 29, 30, 28, 29, 30, 26, 29, 30, 26, 29, + 30, 27, 29, 30, 23, 29, 30, 23, 29, 30, + 10, 17, 29, 30, 23, 29, 30, 23, 29, 30, + 3, 30, 4, 30, 3, 5, 30, 3, 30, 9, + 30, 7, 30, 8, 9, 30, 10, 17, 17, 17, + 15, 1, 6, 15, 14, 15, 26, 27, 23, 22, + 23, 23, 10, 17, 23, 23, 23, 2, 15, 15, + + 21, 23, 23, 18, 23, 19, 23, 23, 23, 20, + 23,16400, 23, 13, 22, 23, 12, 22, 23, 18, + 19, 20, 23, 19, 23, 20, 23, 20, 23, 8208, + 8208, 13, 23, 12, 23, 20, 23, 23, 23, 23, + 23, 23, 18, 23, 23, 23, 18,16400 + } ; + +static lp_yyconst short int lp_yy_accept[126] = + { 0, + 1, 2, 3, 3, 3, 3, 3, 4, 6, 10, + 13, 16, 19, 22, 24, 26, 30, 33, 36, 39, + 42, 45, 48, 51, 55, 58, 61, 63, 65, 68, + 70, 72, 74, 77, 79, 80, 81, 81, 82, 83, + 84, 85, 87, 87, 88, 89, 90, 91, 91, 92, + 93, 95, 95, 95, 96, 97, 98, 99, 99, 100, + 100, 101, 102, 102, 103, 104, 104, 104, 104, 106, + 108, 109, 110, 112, 113, 114, 114, 116, 117, 117, + 119, 120, 121, 122, 123, 124, 126, 128, 130, 131, + 132, 132, 133, 134, 135, 136, 136, 137, 138, 138, + + 138, 139, 140, 140, 141, 141, 141, 142, 143, 143, + 145, 145, 145, 146, 147, 148, 148, 149, 149, 149, + 149, 149, 149, 149, 149 + } ; + +static lp_yyconst int lp_yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 1, 5, 6, 5, 5, 5, 1, + 1, 7, 8, 9, 10, 11, 12, 13, 14, 14, + 13, 13, 13, 13, 13, 13, 13, 15, 16, 17, + 18, 19, 1, 5, 20, 21, 22, 21, 23, 24, + 25, 21, 26, 21, 21, 21, 27, 28, 29, 21, + 21, 30, 31, 32, 33, 21, 21, 34, 35, 36, + 5, 1, 5, 5, 5, 1, 20, 21, 22, 21, + + 23, 24, 25, 21, 26, 21, 21, 21, 27, 28, + 29, 21, 21, 30, 31, 32, 33, 21, 21, 34, + 35, 36, 5, 1, 5, 5, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static lp_yyconst int lp_yy_meta[37] = + { 0, + 1, 2, 2, 2, 3, 4, 5, 2, 5, 2, + 4, 4, 4, 4, 6, 5, 6, 5, 5, 3, + 3, 3, 3, 3, 3, 7, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3 + } ; + +static lp_yyconst short int lp_yy_base[131] = + { 0, + 0, 35, 35, 37, 42, 44, 288, 297, 47, 50, + 297, 257, 297, 49, 52, 54, 297, 297, 261, 297, + 260, 54, 55, 80, 59, 63, 297, 297, 297, 265, + 297, 297, 297, 91, 250, 94, 231, 94, 297, 297, + 96, 101, 108, 297, 297, 74, 243, 0, 108, 111, + 0, 229, 50, 88, 114, 117, 297, 232, 124, 130, + 136, 297, 236, 138, 143, 222, 231, 221, 139, 118, + 142, 146, 156, 163, 236, 41, 235, 157, 98, 234, + 161, 225, 297, 233, 165, 176, 164, 180, 196, 297, + 217, 297, 170, 297, 186, 218, 228, 187, 219, 214, + + 191, 194, 216, 198, 205, 200, 201, 206, 175, 202, + 164, 191, 218, 229, 297, 151, 234, 149, 124, 118, + 101, 94, 54, 297, 260, 267, 273, 278, 283, 289 + } ; + +static lp_yyconst short int lp_yy_def[131] = + { 0, + 124, 1, 125, 125, 126, 126, 124, 124, 124, 124, + 124, 127, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 128, 128, 124, 128, 128, 124, 124, 124, 124, + 124, 124, 124, 124, 127, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 128, 124, 129, 128, 128, + 24, 124, 124, 128, 128, 128, 124, 124, 124, 124, + 124, 124, 129, 128, 128, 124, 124, 124, 128, 128, + 128, 128, 128, 130, 124, 124, 124, 128, 124, 124, + 128, 124, 124, 124, 128, 128, 128, 128, 124, 124, + 124, 124, 128, 124, 128, 124, 124, 128, 124, 124, + + 128, 128, 124, 128, 124, 124, 128, 128, 124, 128, + 124, 124, 128, 128, 124, 124, 130, 124, 124, 124, + 124, 124, 124, 0, 124, 124, 124, 124, 124, 124 + } ; + +static lp_yyconst short int lp_yy_nxt[334] = + { 0, + 8, 9, 10, 9, 8, 8, 11, 12, 13, 12, + 14, 15, 16, 16, 17, 18, 19, 20, 21, 22, + 22, 22, 22, 22, 22, 22, 23, 22, 22, 22, + 22, 22, 22, 22, 22, 22, 24, 28, 29, 28, + 29, 30, 76, 30, 32, 33, 32, 33, 34, 34, + 34, 34, 34, 34, 35, 92, 35, 35, 39, 35, + 25, 38, 38, 40, 41, 26, 42, 42, 47, 47, + 48, 48, 67, 47, 49, 48, 43, 47, 68, 48, + 50, 51, 34, 34, 83, 55, 54, 35, 47, 35, + 48, 56, 34, 34, 34, 36, 36, 36, 35, 79, + + 35, 36, 47, 36, 48, 52, 38, 38, 59, 59, + 53, 41, 94, 42, 42, 60, 43, 60, 43, 69, + 61, 61, 47, 43, 48, 47, 123, 48, 47, 122, + 48, 47, 47, 48, 48, 70, 59, 59, 65, 76, + 71, 64, 61, 61, 79, 72, 43, 73, 61, 61, + 121, 120, 77, 47, 48, 48, 47, 80, 48, 48, + 47, 85, 48, 78, 89, 89, 89, 86, 81, 88, + 47, 47, 48, 48, 119, 47, 87, 48, 47, 47, + 48, 48, 118, 93, 47, 99, 48, 95, 91, 98, + 47, 116, 48, 88, 47, 101, 48, 89, 89, 89, + + 47, 47, 48, 48, 115, 47, 70, 48, 47, 104, + 48, 102, 47, 117, 48, 47, 47, 48, 48, 76, + 47, 107, 48, 113, 108, 117, 107, 110, 114, 108, + 79, 112, 77, 111, 48, 89, 89, 89, 109, 106, + 105, 97, 103, 80, 100, 48, 97, 96, 62, 62, + 47, 84, 83, 82, 75, 74, 66, 62, 58, 124, + 27, 27, 27, 27, 27, 27, 27, 31, 31, 31, + 31, 31, 31, 31, 36, 37, 57, 45, 44, 36, + 46, 46, 37, 46, 46, 63, 63, 124, 124, 63, + 90, 124, 90, 90, 90, 90, 7, 124, 124, 124, + + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124 + } ; + +static lp_yyconst short int lp_yy_chk[334] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 2, 3, 3, 4, + 4, 3, 76, 4, 5, 5, 6, 6, 9, 9, + 9, 10, 10, 10, 9, 76, 9, 10, 15, 10, + 2, 14, 14, 15, 16, 2, 16, 16, 22, 23, + 22, 23, 53, 25, 23, 25, 16, 26, 53, 26, + 23, 24, 24, 24, 123, 26, 25, 24, 46, 24, + 46, 26, 34, 34, 34, 36, 36, 36, 34, 79, + + 34, 36, 54, 36, 54, 24, 38, 38, 41, 41, + 24, 42, 79, 42, 42, 43, 38, 43, 41, 54, + 43, 43, 49, 42, 49, 50, 122, 50, 55, 121, + 55, 56, 70, 56, 70, 55, 59, 59, 50, 64, + 55, 49, 60, 60, 65, 55, 59, 56, 61, 61, + 120, 119, 64, 69, 64, 69, 71, 65, 71, 65, + 72, 69, 72, 64, 74, 74, 74, 71, 65, 73, + 73, 78, 73, 78, 118, 81, 72, 81, 87, 85, + 87, 85, 116, 78, 93, 86, 93, 81, 74, 85, + 86, 111, 86, 88, 88, 93, 88, 89, 89, 89, + + 95, 98, 95, 98, 109, 101, 86, 101, 102, 98, + 102, 95, 104, 112, 104, 107, 110, 107, 110, 113, + 108, 101, 108, 107, 102, 112, 101, 104, 108, 102, + 114, 106, 113, 105, 113, 117, 117, 117, 103, 100, + 99, 97, 96, 114, 91, 114, 84, 82, 80, 77, + 75, 68, 67, 66, 63, 58, 52, 47, 37, 117, + 125, 125, 125, 125, 125, 125, 125, 126, 126, 126, + 126, 126, 126, 126, 127, 35, 30, 21, 19, 127, + 128, 128, 12, 128, 128, 129, 129, 7, 0, 129, + 130, 0, 130, 130, 130, 130, 124, 124, 124, 124, + + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 124 + } ; + +static lp_yy_state_type lp_yy_state_buf[YY_BUF_SIZE + 2], *lp_yy_state_ptr; +static char *lp_yy_full_match; +static int lp_yy_lp; +static int lp_yy_looking_for_trail_begin = 0; +static int lp_yy_full_lp; +static int *lp_yy_full_state; +#define YY_TRAILING_MASK 0x2000 +#define YY_TRAILING_HEAD_MASK 0x4000 +#define REJECT \ +{ \ +*lp_yy_cp = lp_yy_hold_char; /* undo effects of setting up lp_yytext */ \ +lp_yy_cp = lp_yy_full_match; /* restore poss. backed-over text */ \ +lp_yy_lp = lp_yy_full_lp; /* restore orig. accepting pos. */ \ +lp_yy_state_ptr = lp_yy_full_state; /* restore orig. state */ \ +lp_yy_current_state = *lp_yy_state_ptr; /* restore curr. state */ \ +++lp_yy_lp; \ +goto find_rule; \ +} +static int lp_yy_more_offset = 0; +static int lp_yy_prev_more_offset = 0; +#define lp_yymore() (lp_yy_more_offset = lp_yy_flex_strlen( lp_yytext )) +#define YY_NEED_STRLEN +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET \ + { \ + lp_yy_more_offset = lp_yy_prev_more_offset; \ + lp_yyleng -= lp_yy_more_offset; \ + } +#ifndef YYLMAX +#define YYLMAX 8192 +#endif + +char lp_yytext[YYLMAX]; +char *lp_yytext_ptr; +#define INITIAL 0 +#define COMMENT 1 + +#define LINECOMMENT 2 + + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int lp_yywrap YY_PROTO(( void )); +#else +extern int lp_yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void lp_yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef lp_yytext_ptr +static void lp_yy_flex_strncpy YY_PROTO(( char *, lp_yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int lp_yy_flex_strlen YY_PROTO(( lp_yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int lp_yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int lp_yy_start_stack_ptr = 0; +static int lp_yy_start_stack_depth = 0; +static int *lp_yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void lp_yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void lp_yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int lp_yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( lp_yytext, lp_yyleng, 1, lp_yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( lp_yy_current_buffer->lp_yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( lp_yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( lp_yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, lp_yyin )) == 0) \ + && ferror( lp_yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "lp_yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef lp_yyterminate +#define lp_yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) lp_yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int lp_yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after lp_yytext and lp_yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + if ( lp_yyleng > 0 ) \ + lp_yy_current_buffer->lp_yy_at_bol = \ + (lp_yytext[lp_yyleng - 1] == '\n'); \ + YY_USER_ACTION + +YY_DECL + { + register lp_yy_state_type lp_yy_current_state; + register char *lp_yy_cp, *lp_yy_bp; + register int lp_yy_act; + + + + if ( lp_yy_init ) + { + lp_yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! lp_yy_start ) + lp_yy_start = 1; /* first start state */ + + if ( ! lp_yyin ) + lp_yyin = stdin; + + if ( ! lp_yyout ) + lp_yyout = stdout; + + if ( ! lp_yy_current_buffer ) + lp_yy_current_buffer = + lp_yy_create_buffer( lp_yyin, YY_BUF_SIZE ); + + lp_yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + lp_yy_cp = lp_yy_c_buf_p; + + /* Support of lp_yytext. */ + *lp_yy_cp = lp_yy_hold_char; + + /* lp_yy_bp points to the position in lp_yy_ch_buf of the start of + * the current run. + */ + lp_yy_bp = lp_yy_cp; + + lp_yy_current_state = lp_yy_start; + lp_yy_current_state += YY_AT_BOL(); + lp_yy_state_ptr = lp_yy_state_buf; + *lp_yy_state_ptr++ = lp_yy_current_state; +lp_yy_match: + do + { + register YY_CHAR lp_yy_c = lp_yy_ec[YY_SC_TO_UI(*lp_yy_cp)]; + while ( lp_yy_chk[lp_yy_base[lp_yy_current_state] + lp_yy_c] != lp_yy_current_state ) + { + lp_yy_current_state = (int) lp_yy_def[lp_yy_current_state]; + if ( lp_yy_current_state >= 125 ) + lp_yy_c = lp_yy_meta[(unsigned int) lp_yy_c]; + } + lp_yy_current_state = lp_yy_nxt[lp_yy_base[lp_yy_current_state] + (unsigned int) lp_yy_c]; + *lp_yy_state_ptr++ = lp_yy_current_state; + ++lp_yy_cp; + } + while ( lp_yy_base[lp_yy_current_state] != 297 ); + +lp_yy_find_action: + lp_yy_current_state = *--lp_yy_state_ptr; + lp_yy_lp = lp_yy_accept[lp_yy_current_state]; +find_rule: /* we branch to this label when backing up */ + for ( ; ; ) /* until we find what rule we matched */ + { + if ( lp_yy_lp && lp_yy_lp < lp_yy_accept[lp_yy_current_state + 1] ) + { + lp_yy_act = lp_yy_acclist[lp_yy_lp]; + if ( lp_yy_act & YY_TRAILING_HEAD_MASK || + lp_yy_looking_for_trail_begin ) + { + if ( lp_yy_act == lp_yy_looking_for_trail_begin ) + { + lp_yy_looking_for_trail_begin = 0; + lp_yy_act &= ~YY_TRAILING_HEAD_MASK; + break; + } + } + else if ( lp_yy_act & YY_TRAILING_MASK ) + { + lp_yy_looking_for_trail_begin = lp_yy_act & ~YY_TRAILING_MASK; + lp_yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK; + lp_yy_full_match = lp_yy_cp; + lp_yy_full_state = lp_yy_state_ptr; + lp_yy_full_lp = lp_yy_lp; + } + else + { + lp_yy_full_match = lp_yy_cp; + lp_yy_full_state = lp_yy_state_ptr; + lp_yy_full_lp = lp_yy_lp; + break; + } + ++lp_yy_lp; + goto find_rule; + } + --lp_yy_cp; + lp_yy_current_state = *--lp_yy_state_ptr; + lp_yy_lp = lp_yy_accept[lp_yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + if ( lp_yy_act != YY_END_OF_BUFFER ) + { + int lp_yyl; + for ( lp_yyl = 0; lp_yyl < lp_yyleng; ++lp_yyl ) + if ( lp_yytext[lp_yyl] == '\n' ) + ++lp_yylineno; + } + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( lp_yy_act ) + { /* beginning of action switch */ +case 1: +YY_RULE_SETUP +{ + BEGIN COMMENT; +} /* begin skip comment */ + YY_BREAK +case 2: +YY_RULE_SETUP +{ + BEGIN INITIAL; +} /* end skip comment */ + YY_BREAK +case 3: +YY_RULE_SETUP +{ +} + YY_BREAK +case 4: +YY_RULE_SETUP +{ +} + YY_BREAK +case 5: +YY_RULE_SETUP +{ +} + YY_BREAK +case 6: +YY_RULE_SETUP +{ + BEGIN LINECOMMENT; +} /* begin skip LINECOMMENT */ + YY_BREAK +case 7: +YY_RULE_SETUP +{ + BEGIN INITIAL; +} /* end skip LINECOMMENT */ + YY_BREAK +case 8: +YY_RULE_SETUP +{ + BEGIN INITIAL; +} /* end skip LINECOMMENT */ + YY_BREAK +case 9: +YY_RULE_SETUP +{ +} + YY_BREAK +case 10: +YY_RULE_SETUP +{ +} + YY_BREAK +case 11: +YY_RULE_SETUP +{ + return(COMMA); +} + YY_BREAK +case 12: +YY_RULE_SETUP +{ + return(MINIMISE); +} + YY_BREAK +case 13: +YY_RULE_SETUP +{ + return(MAXIMISE); +} + YY_BREAK +case 14: +YY_RULE_SETUP +{ + f = atof((char *)lp_yytext); + return(INTCONS); +} /* f contains the last float */ + YY_BREAK +case 15: +YY_RULE_SETUP +{ + f = atof((char *)lp_yytext); + return(CONS); +} /* f contains the last float */ + YY_BREAK +case 16: +YY_RULE_SETUP +{ + char *ptr; + + f = DEF_INFINITE; + Sign = 0; + ptr = (char *)lp_yytext; + while (isspace(*ptr)) ptr++; + if(*ptr == '-') + Sign = 1; + return(INF); +} /* f contains the last float */ + YY_BREAK +case 17: +YY_RULE_SETUP +{ + Sign = 0; + for(x = 0; x < lp_yyleng; x++) + if(lp_yytext[x] == '-' || lp_yytext[x] == '+') + Sign = (Sign == (lp_yytext[x] == '+')); + return (SIGN); + /* Sign is TRUE if the sign-string + represents a '-'. Otherwise Sign + is FALSE */ +} + YY_BREAK +case 18: +YY_RULE_SETUP +{ + if((!Within_int_decl) && (!Within_sec_decl) && (!Within_sos_decl)) { + Within_int_decl = TRUE; + Within_sos_decl1 = FALSE; + } + return(SEC_INT); +} + YY_BREAK +case 19: +YY_RULE_SETUP +{ + if((!Within_int_decl) && (!Within_sec_decl) && (!Within_sos_decl)) { + Within_sec_decl = TRUE; + Within_sos_decl1 = FALSE; + } + return(SEC_SEC); +} + YY_BREAK +case 20: +YY_RULE_SETUP +{ + if(!Within_sos_decl) + SOStype0 = (short)atoi(((char *)lp_yytext) + 3); + if((!Within_int_decl) && (!Within_sec_decl) && (!Within_sos_decl)) + Within_sos_decl = TRUE; + return(SEC_SOS); +} + YY_BREAK +case 21: +YY_RULE_SETUP +{ + FREE(Last_var); + Last_var = strdup((char *)lp_yytext); + Last_var[strlen(Last_var) - 2] = 0; + return(SOSDESCR); +} + YY_BREAK +case 22: +YY_RULE_SETUP +{ + FREE(Last_var); + Last_var = strdup((char *)lp_yytext); + Last_var[strlen(Last_var) - 1] = 0; + return(VARIABLECOLON); +} + YY_BREAK +case 23: +YY_RULE_SETUP +{ + FREE(Last_var); + Last_var = strdup((char *)lp_yytext); + return(VAR); +} + YY_BREAK +case 24: +YY_RULE_SETUP +{ + return (COLON); +} + YY_BREAK +case 25: +YY_RULE_SETUP +{ + return(AR_M_OP); +} + YY_BREAK +case 26: +YY_RULE_SETUP +{ + return(RE_OPLE); +} + YY_BREAK +case 27: +YY_RULE_SETUP +{ + return(RE_OPGE); +} + YY_BREAK +case 28: +YY_RULE_SETUP +{ + Within_int_decl = Within_sec_decl = Within_sos_decl = FALSE; + check_int_sec_sos_decl(Within_int_decl, Within_sec_decl, Within_sos_decl); + return(END_C); +} + YY_BREAK +case 29: +YY_RULE_SETUP +{ + report(NULL, CRITICAL, "LEX ERROR : %s lineno %d\n", lp_yytext, lp_yylineno); + return(UNDEFINED); +} + YY_BREAK +case 30: +YY_RULE_SETUP +ECHO; + YY_BREAK + case YY_STATE_EOF(INITIAL): + case YY_STATE_EOF(COMMENT): + case YY_STATE_EOF(LINECOMMENT): + lp_yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int lp_yy_amount_of_matched_text = (int) (lp_yy_cp - lp_yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *lp_yy_cp = lp_yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( lp_yy_current_buffer->lp_yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed lp_yyin at a new source and called + * lp_yylex(). If so, then we have to assure + * consistency between lp_yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + lp_yy_n_chars = lp_yy_current_buffer->lp_yy_n_chars; + lp_yy_current_buffer->lp_yy_input_file = lp_yyin; + lp_yy_current_buffer->lp_yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for lp_yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since lp_yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( lp_yy_c_buf_p <= &lp_yy_current_buffer->lp_yy_ch_buf[lp_yy_n_chars] ) + { /* This was really a NUL. */ + lp_yy_state_type lp_yy_next_state; + + lp_yy_c_buf_p = lp_yytext_ptr + lp_yy_amount_of_matched_text; + + lp_yy_current_state = lp_yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * lp_yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + lp_yy_next_state = lp_yy_try_NUL_trans( lp_yy_current_state ); + + lp_yy_bp = lp_yytext_ptr + YY_MORE_ADJ; + + if ( lp_yy_next_state ) + { + /* Consume the NUL. */ + lp_yy_cp = ++lp_yy_c_buf_p; + lp_yy_current_state = lp_yy_next_state; + goto lp_yy_match; + } + + else + { + lp_yy_cp = lp_yy_c_buf_p; + goto lp_yy_find_action; + } + } + + else switch ( lp_yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + lp_yy_did_buffer_switch_on_eof = 0; + + if ( lp_yywrap() ) + { + /* Note: because we've taken care in + * lp_yy_get_next_buffer() to have set up + * lp_yytext, we can now set up + * lp_yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + lp_yy_c_buf_p = lp_yytext_ptr + YY_MORE_ADJ; + + lp_yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! lp_yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + lp_yy_c_buf_p = + lp_yytext_ptr + lp_yy_amount_of_matched_text; + + lp_yy_current_state = lp_yy_get_previous_state(); + + lp_yy_cp = lp_yy_c_buf_p; + lp_yy_bp = lp_yytext_ptr + YY_MORE_ADJ; + goto lp_yy_match; + + case EOB_ACT_LAST_MATCH: + lp_yy_c_buf_p = + &lp_yy_current_buffer->lp_yy_ch_buf[lp_yy_n_chars]; + + lp_yy_current_state = lp_yy_get_previous_state(); + + lp_yy_cp = lp_yy_c_buf_p; + lp_yy_bp = lp_yytext_ptr + YY_MORE_ADJ; + goto lp_yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of lp_yylex */ + + +/* lp_yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int lp_yy_get_next_buffer() + { + register char *dest = lp_yy_current_buffer->lp_yy_ch_buf; + register char *source = lp_yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( lp_yy_c_buf_p > &lp_yy_current_buffer->lp_yy_ch_buf[lp_yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( lp_yy_current_buffer->lp_yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( lp_yy_c_buf_p - lp_yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (lp_yy_c_buf_p - lp_yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( lp_yy_current_buffer->lp_yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + lp_yy_current_buffer->lp_yy_n_chars = lp_yy_n_chars = 0; + + else + { + int num_to_read = + lp_yy_current_buffer->lp_yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = lp_yy_current_buffer; + + int lp_yy_c_buf_p_offset = + (int) (lp_yy_c_buf_p - b->lp_yy_ch_buf); + + if ( b->lp_yy_is_our_buffer ) + { + int new_size = b->lp_yy_buf_size * 2; + + if ( new_size <= 0 ) + b->lp_yy_buf_size += b->lp_yy_buf_size / 8; + else + b->lp_yy_buf_size *= 2; + + b->lp_yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + lp_yy_flex_realloc( (void *) b->lp_yy_ch_buf, + b->lp_yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->lp_yy_ch_buf = 0; + + if ( ! b->lp_yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + lp_yy_c_buf_p = &b->lp_yy_ch_buf[lp_yy_c_buf_p_offset]; + + num_to_read = lp_yy_current_buffer->lp_yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&lp_yy_current_buffer->lp_yy_ch_buf[number_to_move]), + lp_yy_n_chars, num_to_read ); + + lp_yy_current_buffer->lp_yy_n_chars = lp_yy_n_chars; + } + + if ( lp_yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + lp_yyrestart( lp_yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + lp_yy_current_buffer->lp_yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + lp_yy_n_chars += number_to_move; + lp_yy_current_buffer->lp_yy_ch_buf[lp_yy_n_chars] = YY_END_OF_BUFFER_CHAR; + lp_yy_current_buffer->lp_yy_ch_buf[lp_yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + lp_yytext_ptr = &lp_yy_current_buffer->lp_yy_ch_buf[0]; + + return ret_val; + } + + +/* lp_yy_get_previous_state - get the state just before the EOB char was reached */ + +static lp_yy_state_type lp_yy_get_previous_state() + { + register lp_yy_state_type lp_yy_current_state; + register char *lp_yy_cp; + + lp_yy_current_state = lp_yy_start; + lp_yy_current_state += YY_AT_BOL(); + lp_yy_state_ptr = lp_yy_state_buf; + *lp_yy_state_ptr++ = lp_yy_current_state; + + for ( lp_yy_cp = lp_yytext_ptr + YY_MORE_ADJ; lp_yy_cp < lp_yy_c_buf_p; ++lp_yy_cp ) + { + register YY_CHAR lp_yy_c = (*lp_yy_cp ? lp_yy_ec[YY_SC_TO_UI(*lp_yy_cp)] : 1); + while ( lp_yy_chk[lp_yy_base[lp_yy_current_state] + lp_yy_c] != lp_yy_current_state ) + { + lp_yy_current_state = (int) lp_yy_def[lp_yy_current_state]; + if ( lp_yy_current_state >= 125 ) + lp_yy_c = lp_yy_meta[(unsigned int) lp_yy_c]; + } + lp_yy_current_state = lp_yy_nxt[lp_yy_base[lp_yy_current_state] + (unsigned int) lp_yy_c]; + *lp_yy_state_ptr++ = lp_yy_current_state; + } + + return lp_yy_current_state; + } + + +/* lp_yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = lp_yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static lp_yy_state_type lp_yy_try_NUL_trans( lp_yy_state_type lp_yy_current_state ) +#else +static lp_yy_state_type lp_yy_try_NUL_trans( lp_yy_current_state ) +lp_yy_state_type lp_yy_current_state; +#endif + { + register int lp_yy_is_jam; + + register YY_CHAR lp_yy_c = 1; + while ( lp_yy_chk[lp_yy_base[lp_yy_current_state] + lp_yy_c] != lp_yy_current_state ) + { + lp_yy_current_state = (int) lp_yy_def[lp_yy_current_state]; + if ( lp_yy_current_state >= 125 ) + lp_yy_c = lp_yy_meta[(unsigned int) lp_yy_c]; + } + lp_yy_current_state = lp_yy_nxt[lp_yy_base[lp_yy_current_state] + (unsigned int) lp_yy_c]; + lp_yy_is_jam = (lp_yy_current_state == 124); + if ( ! lp_yy_is_jam ) + *lp_yy_state_ptr++ = lp_yy_current_state; + + return lp_yy_is_jam ? 0 : lp_yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void lp_yyunput( int c, register char *lp_yy_bp ) +#else +static void lp_yyunput( c, lp_yy_bp ) +int c; +register char *lp_yy_bp; +#endif + { + register char *lp_yy_cp = lp_yy_c_buf_p; + + /* undo effects of setting up lp_yytext */ + *lp_yy_cp = lp_yy_hold_char; + + if ( lp_yy_cp < lp_yy_current_buffer->lp_yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = lp_yy_n_chars + 2; + register char *dest = &lp_yy_current_buffer->lp_yy_ch_buf[ + lp_yy_current_buffer->lp_yy_buf_size + 2]; + register char *source = + &lp_yy_current_buffer->lp_yy_ch_buf[number_to_move]; + + while ( source > lp_yy_current_buffer->lp_yy_ch_buf ) + *--dest = *--source; + + lp_yy_cp += (int) (dest - source); + lp_yy_bp += (int) (dest - source); + lp_yy_current_buffer->lp_yy_n_chars = + lp_yy_n_chars = lp_yy_current_buffer->lp_yy_buf_size; + + if ( lp_yy_cp < lp_yy_current_buffer->lp_yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--lp_yy_cp = (char) c; + + if ( c == '\n' ) + --lp_yylineno; + + lp_yytext_ptr = lp_yy_bp; + lp_yy_hold_char = *lp_yy_cp; + lp_yy_c_buf_p = lp_yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int lp_yyinput() +#else +static int input() +#endif + { + int c; + + *lp_yy_c_buf_p = lp_yy_hold_char; + + if ( *lp_yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* lp_yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( lp_yy_c_buf_p < &lp_yy_current_buffer->lp_yy_ch_buf[lp_yy_n_chars] ) + /* This was really a NUL. */ + *lp_yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = lp_yy_c_buf_p - lp_yytext_ptr; + ++lp_yy_c_buf_p; + + switch ( lp_yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because lp_yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + lp_yyrestart( lp_yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( lp_yywrap() ) + return EOF; + + if ( ! lp_yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return lp_yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + lp_yy_c_buf_p = lp_yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) lp_yy_c_buf_p; /* cast for 8-bit char's */ + *lp_yy_c_buf_p = '\0'; /* preserve lp_yytext */ + lp_yy_hold_char = *++lp_yy_c_buf_p; + + lp_yy_current_buffer->lp_yy_at_bol = (c == '\n'); + if ( lp_yy_current_buffer->lp_yy_at_bol ) + ++lp_yylineno; + + return c; + } + + +#ifdef YY_USE_PROTOS +void lp_yyrestart( FILE *input_file ) +#else +void lp_yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! lp_yy_current_buffer ) + lp_yy_current_buffer = lp_yy_create_buffer( lp_yyin, YY_BUF_SIZE ); + + lp_yy_init_buffer( lp_yy_current_buffer, input_file ); + lp_yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void lp_yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void lp_yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( lp_yy_current_buffer == new_buffer ) + return; + + if ( lp_yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *lp_yy_c_buf_p = lp_yy_hold_char; + lp_yy_current_buffer->lp_yy_buf_pos = lp_yy_c_buf_p; + lp_yy_current_buffer->lp_yy_n_chars = lp_yy_n_chars; + } + + lp_yy_current_buffer = new_buffer; + lp_yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (lp_yywrap()) processing, but the only time this flag + * is looked at is after lp_yywrap() is called, so it's safe + * to go ahead and always set it. + */ + lp_yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void lp_yy_load_buffer_state( void ) +#else +void lp_yy_load_buffer_state() +#endif + { + lp_yy_n_chars = lp_yy_current_buffer->lp_yy_n_chars; + lp_yytext_ptr = lp_yy_c_buf_p = lp_yy_current_buffer->lp_yy_buf_pos; + lp_yyin = lp_yy_current_buffer->lp_yy_input_file; + lp_yy_hold_char = *lp_yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE lp_yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE lp_yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) lp_yy_flex_alloc( sizeof( struct lp_yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in lp_yy_create_buffer()" ); + + b->lp_yy_buf_size = size; + + /* lp_yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->lp_yy_ch_buf = (char *) lp_yy_flex_alloc( b->lp_yy_buf_size + 2 ); + if ( ! b->lp_yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in lp_yy_create_buffer()" ); + + b->lp_yy_is_our_buffer = 1; + + lp_yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void lp_yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void lp_yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == lp_yy_current_buffer ) + lp_yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->lp_yy_is_our_buffer ) + lp_yy_flex_free( (void *) b->lp_yy_ch_buf ); + + lp_yy_flex_free( (void *) b ); + } + + +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif + +#ifdef YY_USE_PROTOS +void lp_yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void lp_yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + lp_yy_flush_buffer( b ); + + b->lp_yy_input_file = file; + b->lp_yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->lp_yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->lp_yy_is_interactive = 0; +#else + b->lp_yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void lp_yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void lp_yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->lp_yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->lp_yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->lp_yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->lp_yy_buf_pos = &b->lp_yy_ch_buf[0]; + + b->lp_yy_at_bol = 1; + b->lp_yy_buffer_status = YY_BUFFER_NEW; + + if ( b == lp_yy_current_buffer ) + lp_yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE lp_yy_scan_buffer( char *base, lp_yy_size_t size ) +#else +YY_BUFFER_STATE lp_yy_scan_buffer( base, size ) +char *base; +lp_yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) lp_yy_flex_alloc( sizeof( struct lp_yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in lp_yy_scan_buffer()" ); + + b->lp_yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->lp_yy_buf_pos = b->lp_yy_ch_buf = base; + b->lp_yy_is_our_buffer = 0; + b->lp_yy_input_file = 0; + b->lp_yy_n_chars = b->lp_yy_buf_size; + b->lp_yy_is_interactive = 0; + b->lp_yy_at_bol = 1; + b->lp_yy_fill_buffer = 0; + b->lp_yy_buffer_status = YY_BUFFER_NEW; + + lp_yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE lp_yy_scan_string( lp_yyconst char *lp_yy_str ) +#else +YY_BUFFER_STATE lp_yy_scan_string( lp_yy_str ) +lp_yyconst char *lp_yy_str; +#endif + { + int len; + for ( len = 0; lp_yy_str[len]; ++len ) + ; + + return lp_yy_scan_bytes( lp_yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE lp_yy_scan_bytes( lp_yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE lp_yy_scan_bytes( bytes, len ) +lp_yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + lp_yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) lp_yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in lp_yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = lp_yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in lp_yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->lp_yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void lp_yy_push_state( int new_state ) +#else +static void lp_yy_push_state( new_state ) +int new_state; +#endif + { + if ( lp_yy_start_stack_ptr >= lp_yy_start_stack_depth ) + { + lp_yy_size_t new_size; + + lp_yy_start_stack_depth += YY_START_STACK_INCR; + new_size = lp_yy_start_stack_depth * sizeof( int ); + + if ( ! lp_yy_start_stack ) + lp_yy_start_stack = (int *) lp_yy_flex_alloc( new_size ); + + else + lp_yy_start_stack = (int *) lp_yy_flex_realloc( + (void *) lp_yy_start_stack, new_size ); + + if ( ! lp_yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + lp_yy_start_stack[lp_yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void lp_yy_pop_state() + { + if ( --lp_yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(lp_yy_start_stack[lp_yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int lp_yy_top_state() + { + return lp_yy_start_stack[lp_yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void lp_yy_fatal_error( lp_yyconst char msg[] ) +#else +static void lp_yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine lp_yyless() so it works in section 3 code. */ + +#undef lp_yyless +#define lp_yyless(n) \ + do \ + { \ + /* Undo effects of setting up lp_yytext. */ \ + lp_yytext[lp_yyleng] = lp_yy_hold_char; \ + lp_yy_c_buf_p = lp_yytext + n; \ + lp_yy_hold_char = *lp_yy_c_buf_p; \ + *lp_yy_c_buf_p = '\0'; \ + lp_yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef lp_yytext_ptr +#ifdef YY_USE_PROTOS +static void lp_yy_flex_strncpy( char *s1, lp_yyconst char *s2, int n ) +#else +static void lp_yy_flex_strncpy( s1, s2, n ) +char *s1; +lp_yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int lp_yy_flex_strlen( lp_yyconst char *s ) +#else +static int lp_yy_flex_strlen( s ) +lp_yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *lp_yy_flex_alloc( lp_yy_size_t size ) +#else +static void *lp_yy_flex_alloc( size ) +lp_yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *lp_yy_flex_realloc( void *ptr, lp_yy_size_t size ) +#else +static void *lp_yy_flex_realloc( ptr, size ) +void *ptr; +lp_yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void lp_yy_flex_free( void *ptr ) +#else +static void lp_yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + lp_yylex(); + return 0; + } +#endif + diff --git a/include/lp_scale.h b/include/lp_scale.h new file mode 100644 index 0000000..2aa8cc6 --- /dev/null +++ b/include/lp_scale.h @@ -0,0 +1,31 @@ +#ifndef HEADER_lp_scale +#define HEADER_lp_scale + +#include "lp_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* Put function headers here */ +STATIC MYBOOL scale_updatecolumns(lprec *lp, REAL *scalechange, MYBOOL updateonly); +STATIC MYBOOL scale_updaterows(lprec *lp, REAL *scalechange, MYBOOL updateonly); +STATIC MYBOOL scale_rows(lprec *lp, REAL *scaledelta); +STATIC MYBOOL scale_columns(lprec *lp, REAL *scaledelta); +STATIC void unscale_columns(lprec *lp); +STATIC REAL scale(lprec *lp, REAL *scaledelta); +STATIC REAL scaled_mat(lprec *lp, REAL value, int rownr, int colnr); +STATIC REAL unscaled_mat(lprec *lp, REAL value, int rownr, int colnr); +STATIC REAL scaled_value(lprec *lp, REAL value, int index); +STATIC REAL unscaled_value(lprec *lp, REAL value, int index); +STATIC MYBOOL scaleCR(lprec *lp, REAL *scaledelta); +STATIC MYBOOL finalize_scaling(lprec *lp, REAL *scaledelta); +STATIC REAL auto_scale(lprec *lp); +void undoscale(lprec *lp); + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_lp_scale */ + diff --git a/include/lp_simplex.h b/include/lp_simplex.h new file mode 100644 index 0000000..d973f72 --- /dev/null +++ b/include/lp_simplex.h @@ -0,0 +1,34 @@ +#ifndef HEADER_lp_simplex +#define HEADER_lp_simplex + +#include "lp_types.h" + +#define ForceDualSimplexInBB /* Force use/switch of dual simplex in B&B */ +#define AssumeHighAccuracyInBB /* No iteration of simplex solves at infeasibility */ +/*#define UseLongStepPruning*/ +/*#define UseLongStepDualPhase1*/ +#define primal_UseRejectionList +#define dual_UseRejectionList +#define dual_RemoveBasicFixedVars +/*#define dual_Phase1PriceEqualities */ /* Force elimination of equality slacks */ +#define AcceptMarginalAccuracy + +#ifdef __cplusplus +extern "C" { +#endif + +/* Put function headers here */ +STATIC int primloop(lprec *lp, MYBOOL primalfeasible, REAL primaloffset); +STATIC int dualloop(lprec *lp, MYBOOL dualfeasible, int dualinfeasibles[], REAL dualoffset); +STATIC int spx_run(lprec *lp, MYBOOL validInvB); +STATIC int spx_solve(lprec *lp); +STATIC int lag_solve(lprec *lp, REAL start_bound, int num_iter); +STATIC int heuristics(lprec *lp, int mode); +STATIC int lin_solve(lprec *lp); + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_lp_simplex */ + diff --git a/include/lp_solveDLL.h b/include/lp_solveDLL.h new file mode 100644 index 0000000..ebf98af --- /dev/null +++ b/include/lp_solveDLL.h @@ -0,0 +1,24 @@ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__22BF6D92_917F_4BDF_B806_0954721EBA95__INCLUDED_) +#define AFX_STDAFX_H__22BF6D92_917F_4BDF_B806_0954721EBA95__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + + +// Insert your headers here +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include + +// TODO: reference additional headers your program requires here + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__22BF6D92_917F_4BDF_B806_0954721EBA95__INCLUDED_) diff --git a/include/lp_types.h b/include/lp_types.h new file mode 100644 index 0000000..dd42a44 --- /dev/null +++ b/include/lp_types.h @@ -0,0 +1,326 @@ +#ifndef HEADER_lp_types +#define HEADER_lp_types + +/* Define data types */ +/* ------------------------------------------------------------------------- */ +#ifndef LLONG + #if defined __BORLANDC__ + #define LLONG __int64 + #elif !defined _MSC_VER || _MSC_VER >= 1310 + #define LLONG long long + #else + #define LLONG __int64 + #endif +#endif + +#ifndef COUNTER + #define COUNTER LLONG +#endif + +#ifndef REAL + #define REAL double +#endif + +#ifndef REALXP + #if 1 + #define REALXP long double /* Set local accumulation variable as long double */ + #else + #define REALXP REAL /* Set local accumulation as default precision */ + #endif +#endif + +#ifndef LREAL + #if 0 + #define LREAL long double /* Set global solution update variable as long double */ + #else + #define LREAL REAL /* Set global solution update variable as default precision */ + #endif +#endif + +#define RESULTVALUEMASK "%18.12g" /* Set fixed-format real-valued output precision; + suggested width: ABS(exponent of DEF_EPSVALUE)+6. */ +#define INDEXVALUEMASK "%8d" /* Set fixed-format integer-valued output width */ + +#ifndef DEF_STRBUFSIZE + #define DEF_STRBUFSIZE 512 +#endif +#ifndef MAXINT32 + #define MAXINT32 2147483647 +#endif +#ifndef MAXUINT32 + #define MAXUINT32 4294967295 +#endif + +#ifndef MAXINT64 + #if defined _LONGLONG || defined __LONG_LONG_MAX__ || defined LLONG_MAX + #define MAXINT64 9223372036854775807ll + #else + #define MAXINT64 9223372036854775807l + #endif +#endif +#ifndef MAXUINT64 + #if defined _LONGLONG || defined __LONG_LONG_MAX__ || defined LLONG_MAX + #define MAXUINT64 18446744073709551616ll + #else + #define MAXUINT64 18446744073709551616l + #endif +#endif + +#ifndef CHAR_BIT + #define CHAR_BIT 8 +#endif +#ifndef MYBOOL + #define MYBOOL unsigned char /* Conserve memory, could be unsigned int */ +#endif + + +/* Constants */ +/* ------------------------------------------------------------------------- */ +#ifndef NULL + #define NULL 0 +#endif + +/* Byte-sized Booleans and extended options */ +#define FALSE 0 +#define TRUE 1 +#define AUTOMATIC 2 +#define DYNAMIC 4 + +/* Sorting and comparison constants */ +#define COMP_PREFERCANDIDATE 1 +#define COMP_PREFERNONE 0 +#define COMP_PREFERINCUMBENT -1 + +/* Library load status values */ +#define LIB_LOADED 0 +#define LIB_NOTFOUND 1 +#define LIB_NOINFO 2 +#define LIB_NOFUNCTION 3 +#define LIB_VERINVALID 4 +#define LIB_STR_LOADED "Successfully loaded" +#define LIB_STR_NOTFOUND "File not found" +#define LIB_STR_NOINFO "No version data" +#define LIB_STR_NOFUNCTION "Missing function header" +#define LIB_STR_VERINVALID "Incompatible version" +#define LIB_STR_MAXLEN 23 + + +/* Compiler/target settings */ +/* ------------------------------------------------------------------------- */ +#if (defined _WIN32) || (defined WIN32) || (defined _WIN64) || (defined WIN64) +# define __WINAPI WINAPI +#else +# define __WINAPI +#endif + +#if (defined _WIN32) || (defined WIN32) || (defined _WIN64) || (defined WIN64) +# define __VACALL __cdecl +#else +# define __VACALL +#endif + +#ifndef __BORLANDC__ + + #ifdef _USRDLL + + #if 1 + #define __EXPORT_TYPE __declspec(dllexport) + #else + /* Set up for the Microsoft compiler */ + #ifdef LP_SOLVE_EXPORTS + #define __EXPORT_TYPE __declspec(dllexport) + #else + #define __EXPORT_TYPE __declspec(dllimport) + #endif + #endif + + #else + + #define __EXPORT_TYPE + + #endif + + #ifdef __cplusplus + #define __EXTERN_C extern "C" + #else + #define __EXTERN_C + #endif + +#else /* Otherwise set up for the Borland compiler */ + + #ifdef __DLL__ + + #define _USRDLL + #define __EXTERN_C extern "C" + + #ifdef __READING_THE_DLL + #define __EXPORT_TYPE __import + #else + #define __EXPORT_TYPE __export + #endif + + #else + + #define __EXPORT_TYPE + #define __EXTERN_C extern "C" + + #endif + +#endif + + +#if 0 + #define STATIC static +#else + #define STATIC +#endif + +#if !defined INLINE + #if defined __cplusplus + #define INLINE inline + #elif (defined _WIN32) || (defined WIN32) || (defined _WIN64) || (defined WIN64) + #define INLINE __inline + #else + #define INLINE static + #endif +#endif + +/* Function macros */ +/* ------------------------------------------------------------------------- */ +#define my_limitrange(x, lo, hi) ((x) < (lo) ? (lo) : ((x) > (hi) ? (hi) : (x))) +#ifndef my_mod + #define my_mod(n, m) ((n) % (m)) +#endif +#define my_if(t, x, y) ((t) ? (x) : (y)) +#define my_sign(x) ((x) < 0 ? -1 : 1) +#if 0 + #define my_chsign(t, x) ( ((t) && ((x) != 0)) ? -(x) : (x)) +#else + #define my_chsign(t, x) ( (2*((t) == 0) - 1) * (x) ) /* "Pipelined" */ +#endif +#define my_flipsign(x) ( fabs((REAL) (x)) == 0 ? 0 : -(x) ) +#define my_roundzero(val, eps) if (fabs((REAL) (val)) < eps) val = 0 +#define my_avoidtiny(val, eps) (fabs((REAL) (val)) < eps ? 0 : val) + +#if 1 + #define my_infinite(lp, val) ( (MYBOOL) (fabs(val) >= lp->infinite) ) +#else + #define my_infinite(lp, val) is_infinite(lp, val) +#endif +#define my_inflimit(lp, val) ( my_infinite(lp, val) ? lp->infinite * my_sign(val) : (val) ) +#if 0 + #define my_precision(val, eps) ((fabs((REAL) (val))) < (eps) ? 0 : (val)) +#else + #define my_precision(val, eps) restoreINT(val, eps) +#endif +#define my_reldiff(x, y) (((x) - (y)) / (1.0 + fabs((REAL) (y)))) +#define my_boundstr(x) (fabs(x) < lp->infinite ? sprintf("%g",x) : ((x) < 0 ? "-Inf" : "Inf") ) +#ifndef my_boolstr + #define my_boolstr(x) (!(x) ? "FALSE" : "TRUE") +#endif +#define my_basisstr(isbasic) ((isbasic) ? "BASIC" : "NON-BASIC") +#define my_simplexstr(isdual) ((isdual) ? "DUAL" : "PRIMAL") +#define my_plural_std(count) (count == 1 ? "" : "s") +#define my_plural_y(count) (count == 1 ? "y" : "ies") +#define my_lowbound(x) ((FULLYBOUNDEDSIMPLEX) ? (x) : 0) + + +/* Bound macros usable for both the standard and fully bounded simplex */ +/* ------------------------------------------------------------------------- */ +/* +#define my_lowbo(lp, varnr) ( lp->isfullybounded ? lp->lowbo[varnr] : 0.0 ) +#define my_upbo(lp, varnr) ( lp->isfullybounded ? lp->upbo[varnr] : lp->lowbo[varnr] + lp->upbo[varnr] ) +#define my_rangebo(lp, varnr) ( lp->isfullybounded ? lp->upbo[varnr] - lp->lowbo[varnr] : lp->upbo[varnr] ) +*/ +#define my_lowbo(lp, varnr) ( 0.0 ) +#define my_upbo(lp, varnr) ( lp->lowbo[varnr] + lp->upbo[varnr] ) +#define my_rangebo(lp, varnr) ( lp->upbo[varnr] ) + +#define my_unbounded(lp, varnr) ((lp->upbo[varnr] >= lp->infinite) && (lp->lowbo[varnr] <= -lp->infinite)) +#define my_bounded(lp, varnr) ((lp->upbo[varnr] < lp->infinite) && (lp->lowbo[varnr] > -lp->infinite)) + +/* Forward declarations */ +/* ------------------------------------------------------------------------- */ +typedef struct _lprec lprec; +typedef struct _INVrec INVrec; +union QSORTrec; + +#ifndef UNIONTYPE + #ifdef __cplusplus + #define UNIONTYPE + #else + #define UNIONTYPE union + #endif +#endif + +/* B4 factorization optimization data */ +typedef struct _B4rec +{ + int *B4_var; /* Position of basic columns in the B4 basis */ + int *var_B4; /* Variable in the B4 basis */ + int *B4_row; /* B4 position of the i'th row */ + int *row_B4; /* Original position of the i'th row */ + REAL *wcol; + int *nzwcol; +} B4rec; + +#define OBJ_STEPS 5 +typedef struct _OBJmonrec { + lprec *lp; + int oldpivstrategy, + oldpivrule, pivrule, ruleswitches, + limitstall[2], limitruleswitches, + idxstep[OBJ_STEPS], countstep, startstep, currentstep, + Rcycle, Ccycle, Ncycle, Mcycle, Icount; + REAL thisobj, prevobj, + objstep[OBJ_STEPS], + thisinfeas, previnfeas, + epsvalue; + char spxfunc[10]; + MYBOOL pivdynamic; + MYBOOL isdual; + MYBOOL active; +} OBJmonrec; + +typedef struct _edgerec +{ + REAL *edgeVector; +} edgerec; + +typedef struct _pricerec +{ + REAL theta; + REAL pivot; + REAL epspivot; + int varno; + lprec *lp; + MYBOOL isdual; +} pricerec; +typedef struct _multirec +{ + lprec *lp; + int size; /* The maximum number of multiply priced rows/columns */ + int used; /* The current / active number of multiply priced rows/columns */ + int limit; /* The active/used count at which a full update is triggered */ + pricerec *items; /* Array of best multiply priced rows/columns */ + int *freeList; /* The indeces of available positions in "items" */ + UNIONTYPE QSORTrec *sortedList; /* List of pointers to "pricerec" items in sorted order */ + REAL *stepList; /* Working array (values in sortedList order) */ + REAL *valueList; /* Working array (values in sortedList order) */ + int *indexSet; /* The final exported index list of pivot variables */ + int active; /* Index of currently active multiply priced row/column */ + int retries; + REAL step_base; + REAL step_last; + REAL obj_base; + REAL obj_last; + REAL epszero; + REAL maxpivot; + REAL maxbound; + MYBOOL sorted; + MYBOOL truncinf; + MYBOOL objcheck; + MYBOOL dirty; +} multirec; + +#endif /* HEADER_lp_types */ diff --git a/include/lp_utils.h b/include/lp_utils.h new file mode 100644 index 0000000..b9af81f --- /dev/null +++ b/include/lp_utils.h @@ -0,0 +1,159 @@ +#ifndef HEADER_lp_utils +#define HEADER_lp_utils + +#ifdef FORTIFY + +#include "lp_fortify.h" + +#define allocCHAR allocCHAR_FORTIFY +#define allocMYBOOL allocMYBOOL_FORTIFY +#define allocINT allocINT_FORTIFY +#define allocREAL allocREAL_FORTIFY +#define allocLREAL allocLREAL_FORTIFY + +#endif + +#include "lp_types.h" + +/* Temporary data storage arrays */ +typedef struct _workarraysrec +{ + lprec *lp; + int size; + int count; + char **vectorarray; + int *vectorsize; +} workarraysrec; + +typedef struct _LLrec +{ + int size; /* The allocated list size */ + int count; /* The current entry count */ + int firstitem; + int lastitem; + int *map; /* The list of forward and backward-mapped entries */ +} LLrec; + +typedef struct _PVrec +{ + int count; /* The allocated list item count */ + int *startpos; /* Starting index of the current value */ + REAL *value; /* The list of forward and backward-mapped entries */ + struct _PVrec *parent; /* The parent record in a pushed chain */ +} PVrec; + + +#ifdef __cplusplus +extern "C" { +#endif + +/* Put function headers here */ +STATIC MYBOOL allocCHAR(lprec *lp, char **ptr, int size, MYBOOL clear); +STATIC MYBOOL allocMYBOOL(lprec *lp, MYBOOL **ptr, int size, MYBOOL clear); +STATIC MYBOOL allocINT(lprec *lp, int **ptr, int size, MYBOOL clear); +STATIC MYBOOL allocREAL(lprec *lp, REAL **ptr, int size, MYBOOL clear); +STATIC MYBOOL allocLREAL(lprec *lp, LREAL **ptr, int size, MYBOOL clear); +STATIC MYBOOL allocFREE(lprec *lp, void **ptr); +REAL *cloneREAL(lprec *lp, REAL *origlist, int size); +MYBOOL *cloneMYBOOL(lprec *lp, MYBOOL *origlist, int size); +int *cloneINT(lprec *lp, int *origlist, int size); + +#if defined INLINE +INLINE void set_biton(MYBOOL *bitarray, int item) +{ + bitarray[item / 8] |= (1 << (item % 8)); +} +INLINE void set_bitoff(MYBOOL *bitarray, int item) +{ + bitarray[item / 8] &= ~(1 << (item % 8)); +} +INLINE MYBOOL is_biton(MYBOOL *bitarray, int item) +{ + return( (MYBOOL) ((bitarray[item / 8] & (1 << (item % 8))) != 0) ); +} +#else +void set_biton(MYBOOL *bitarray, int item); +MYBOOL set_bitoff(MYBOOL *bitarray, int item); +MYBOOL is_biton(MYBOOL *bitarray, int item); +#endif +int comp_bits(MYBOOL *bitarray1, MYBOOL *bitarray2, int items); + +STATIC workarraysrec *mempool_create(lprec *lp); +STATIC char *mempool_obtainVector(workarraysrec *mempool, int count, int unitsize); +STATIC MYBOOL mempool_releaseVector(workarraysrec *mempool, char *memvector, MYBOOL forcefree); +STATIC MYBOOL mempool_free(workarraysrec **mempool); + +STATIC void roundVector(LREAL *myvector, int endpos, LREAL roundzero); +STATIC REAL normalizeVector(REAL *myvector, int endpos); + +STATIC void swapINT(int *item1, int *item2); +STATIC void swapREAL(REAL *item1, REAL *item2); +STATIC void swapPTR(void **item1, void **item2); +STATIC REAL restoreINT(REAL valREAL, REAL epsilon); +STATIC REAL roundToPrecision(REAL value, REAL precision); + +STATIC int searchFor(int target, int *attributes, int size, int offset, MYBOOL absolute); + +STATIC MYBOOL isINT(lprec *lp, REAL value); +STATIC MYBOOL isOrigFixed(lprec *lp, int varno); +STATIC void chsign_bounds(REAL *lobound, REAL *upbound); +STATIC REAL rand_uniform(lprec *lp, REAL range); + +/* Doubly linked list routines */ +STATIC int createLink(int size, LLrec **linkmap, MYBOOL *usedpos); +STATIC MYBOOL freeLink(LLrec **linkmap); +STATIC int sizeLink(LLrec *linkmap); +STATIC MYBOOL isActiveLink(LLrec *linkmap, int itemnr); +STATIC int countActiveLink(LLrec *linkmap); +STATIC int countInactiveLink(LLrec *linkmap); +STATIC int firstActiveLink(LLrec *linkmap); +STATIC int lastActiveLink(LLrec *linkmap); +STATIC MYBOOL appendLink(LLrec *linkmap, int newitem); +STATIC MYBOOL insertLink(LLrec *linkmap, int afteritem, int newitem); +STATIC MYBOOL setLink(LLrec *linkmap, int newitem); +STATIC MYBOOL fillLink(LLrec *linkmap); +STATIC int nextActiveLink(LLrec *linkmap, int backitemnr); +STATIC int prevActiveLink(LLrec *linkmap, int forwitemnr); +STATIC int firstInactiveLink(LLrec *linkmap); +STATIC int lastInactiveLink(LLrec *linkmap); +STATIC int nextInactiveLink(LLrec *linkmap, int backitemnr); +STATIC int prevInactiveLink(LLrec *linkmap, int forwitemnr); +STATIC int removeLink(LLrec *linkmap, int itemnr); +STATIC LLrec *cloneLink(LLrec *sourcemap, int newsize, MYBOOL freesource); +STATIC int compareLink(LLrec *linkmap1, LLrec *linkmap2); +STATIC MYBOOL verifyLink(LLrec *linkmap, int itemnr, MYBOOL doappend); + +/* Packed vector routines */ +STATIC PVrec *createPackedVector(int size, REAL *values, int *workvector); +STATIC void pushPackedVector(PVrec *PV, PVrec *parent); +STATIC MYBOOL unpackPackedVector(PVrec *PV, REAL **target); +STATIC REAL getvaluePackedVector(PVrec *PV, int index); +STATIC PVrec *popPackedVector(PVrec *PV); +STATIC MYBOOL freePackedVector(PVrec **PV); + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_lp_utils */ + +#ifdef FORTIFY + +#ifdef CODE_lp_utils +int _Fortify_ret; +#else +extern int _Fortify_ret; +# undef allocCHAR +# undef allocMYBOOL +# undef allocINT +# undef allocREAL +# undef allocLREAL +# define allocCHAR(lp, ptr, size, clear) (Fortify_LINE(__LINE__), Fortify_FILE(__FILE__), _Fortify_ret = allocCHAR_FORTIFY(lp, ptr, size, clear), Fortify_LINE(0), Fortify_FILE(NULL), _Fortify_ret) +# define allocMYBOOL(lp, ptr, size, clear) (Fortify_LINE(__LINE__), Fortify_FILE(__FILE__), _Fortify_ret = allocMYBOOL_FORTIFY(lp, ptr, size, clear), Fortify_LINE(0), Fortify_FILE(NULL), _Fortify_ret) +# define allocINT(lp, ptr, size, clear) (Fortify_LINE(__LINE__), Fortify_FILE(__FILE__), _Fortify_ret = allocINT_FORTIFY(lp, ptr, size, clear), Fortify_LINE(0), Fortify_FILE(NULL), _Fortify_ret) +# define allocREAL(lp, ptr, size, clear) (Fortify_LINE(__LINE__), Fortify_FILE(__FILE__), _Fortify_ret = allocREAL_FORTIFY(lp, ptr, size, clear), Fortify_LINE(0), Fortify_FILE(NULL), _Fortify_ret) +# define allocLREAL(lp, ptr, size, clear) (Fortify_LINE(__LINE__), Fortify_FILE(__FILE__), _Fortify_ret = allocLREAL_FORTIFY(lp, ptr, size, clear), Fortify_LINE(0), Fortify_FILE(NULL), _Fortify_ret) +#endif + +#endif + diff --git a/include/lp_wlp.h b/include/lp_wlp.h new file mode 100644 index 0000000..010858b --- /dev/null +++ b/include/lp_wlp.h @@ -0,0 +1,21 @@ +#ifndef HEADER_lp_lp +#define HEADER_lp_lp + +#include "lp_types.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +/* Put function headers here */ +MYBOOL LP_writefile(lprec *lp, char *filename); +MYBOOL LP_writehandle(lprec *lp, FILE *output); + + +#ifdef __cplusplus + } +#endif + +#endif /* HEADER_lp_lp */ + diff --git a/include/lpkit.h b/include/lpkit.h new file mode 100644 index 0000000..87913a4 --- /dev/null +++ b/include/lpkit.h @@ -0,0 +1,32 @@ +#include "lp_lib.h" +#include "lp_report.h" + +#define MALLOC(ptr, nr, type)\ + ((((nr) == 0) || ((ptr = (type *) malloc((size_t)((nr) * sizeof(*ptr)))) == NULL)) ? \ + report(NULL, CRITICAL, "malloc of %d bytes failed on line %d of file %s\n",\ + (nr) * sizeof(*ptr), __LINE__, __FILE__), (ptr = NULL /* (void *) 0 */) : \ + ptr\ + ) + +#define CALLOC(ptr, nr, type)\ + ((((nr) == 0) || ((ptr = (type *) calloc((size_t)(nr), sizeof(*ptr))) == NULL)) ? \ + report(NULL, CRITICAL, "calloc of %d bytes failed on line %d of file %s\n",\ + (nr) * sizeof(*ptr), __LINE__, __FILE__), (ptr = NULL /* (void *) 0 */) : \ + ptr\ + ) + +#define REALLOC(ptr, nr, type)\ + ((((nr) == 0) || ((ptr = (type *) realloc(ptr, (size_t)((nr) * sizeof(*ptr)))) == NULL)) ? \ + report(NULL, CRITICAL, "realloc of %d bytes failed on line %d of file %s\n",\ + (nr) * sizeof(*ptr), __LINE__, __FILE__), (ptr = NULL /* (void *) 0 */) : \ + ptr\ + ) + +#if defined FREE +# undef FREE +#endif + +#define FREE(ptr) if (ptr != NULL) {free(ptr), ptr = NULL;} else + +#define MALLOCCPY(nptr, optr, nr, type)\ + (MALLOC(nptr, nr, type), (nptr != NULL) ? memcpy(nptr, optr, (size_t)((nr) * sizeof(*optr))) : 0, nptr) diff --git a/include/lpsolve.h b/include/lpsolve.h new file mode 100644 index 0000000..ebf98af --- /dev/null +++ b/include/lpsolve.h @@ -0,0 +1,24 @@ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__22BF6D92_917F_4BDF_B806_0954721EBA95__INCLUDED_) +#define AFX_STDAFX_H__22BF6D92_917F_4BDF_B806_0954721EBA95__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + + +// Insert your headers here +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include + +// TODO: reference additional headers your program requires here + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__22BF6D92_917F_4BDF_B806_0954721EBA95__INCLUDED_) diff --git a/include/ufortify.h b/include/ufortify.h new file mode 100644 index 0000000..a495e92 --- /dev/null +++ b/include/ufortify.h @@ -0,0 +1,63 @@ +/* + * FILE: + * ufortify.h + * + * DESCRIPTION: + * User options for fortify. Changes to this file require fortify.c to be + * recompiled, but nothing else. + */ + +#ifndef __UFORTIFY_H__ +#define __UFORTIFY_H__ + +#define FORTIFY_STORAGE + +#if defined MSDOS || defined __BORLANDC__ || defined __HIGHC__ +# define KNOWS_POINTER_TYPE +#endif + +#define FORTIFY_WAIT_FOR_KEY /* Pause after message */ + +#if !defined FORTIFY_BEFORE_SIZE +# define FORTIFY_BEFORE_SIZE 16 /* Bytes to allocate before block */ +#endif + +#if !defined FORTIFY_BEFORE_VALUE +# define FORTIFY_BEFORE_VALUE 0xA3 /* Fill value before block */ +#endif + +#if !defined FORTIFY_AFTER_SIZE +# define FORTIFY_AFTER_SIZE 16 /* Bytes to allocate after block */ +#endif + +#if !defined FORTIFY_AFTER_VALUE +# define FORTIFY_AFTER_VALUE 0xA5 /* Fill value after block */ +#endif + +#define FILL_ON_MALLOC /* Nuke out malloc'd memory */ + +#if !defined FILL_ON_MALLOC_VALUE +# define FILL_ON_MALLOC_VALUE 0xA7 /* Value to initialize with */ +#endif + +#define FILL_ON_FREE /* free'd memory is cleared */ + +#if !defined FILL_ON_FREE_VALUE +# define FILL_ON_FREE_VALUE 0xA9 /* Value to de-initialize with */ +#endif + +#define FORTIFY_CheckInterval 1 /* seconds */ +/* #define CHECK_ALL_MEMORY_ON_MALLOC */ +#define CHECK_ALL_MEMORY_ON_FREE +#define PARANOID_FREE + +#define WARN_ON_MALLOC_FAIL /* A debug is issued on a failed malloc */ +#define WARN_ON_ZERO_MALLOC /* A debug is issued on a malloc(0) */ +#define WARN_ON_FALSE_FAIL /* See Fortify_SetMallocFailRate */ +#define WARN_ON_SIZE_T_OVERFLOW/* Watch for breaking the 64K limit in */ + /* some braindead architectures... */ + +#define FORTIFY_LOCK() +#define FORTIFY_UNLOCK() + +#endif diff --git a/include/yacc_read.h b/include/yacc_read.h new file mode 100644 index 0000000..0fa53f4 --- /dev/null +++ b/include/yacc_read.h @@ -0,0 +1,24 @@ +/* prototypes of functions used in the parser */ + +#ifndef __READ_H__ +#define __READ_H__ + +void lex_fatal_error(char *msg); +int set_title(char *name); +int add_constraint_name(char *name); +int store_re_op(char *yytext, int HadConstraint, int HadVar, int Had_lineair_sum); +void null_tmp_store(int init_Lin_term_count); +int store_bounds(int warn); +void storevarandweight(char *name); +int set_sos_type(int SOStype); +int set_sos_weight(double weight, int sos_decl); +int rhs_store(REAL value, int HadConstraint, int HadVar, int Had_lineair_sum); +int var_store(char *var, REAL value, int HadConstraint, int HadVar, int Had_lineair_sum); +int negate_constraint(void); +void add_row(void); +void set_obj_dir(int maximise); + +void read_error(char *); +void check_int_sec_sos_decl(int, int, int); +lprec *yacc_read(lprec *lp, int verbose, char *lp_name, int *_lineno, int (*parse) (void), void (*delete_allocated_memory) (void)); +#endif diff --git a/interface.H b/interface.H new file mode 100644 index 0000000..b93f2aa --- /dev/null +++ b/interface.H @@ -0,0 +1,5 @@ +#ifndef _INTERFACE_H +#define INTERFACE_H +#include "main.H" +void Y(); +#endif diff --git a/interface.cpp b/interface.cpp new file mode 100644 index 0000000..0df2021 --- /dev/null +++ b/interface.cpp @@ -0,0 +1,695 @@ +#include "interface.H" +extern PPRFA A; +extern Sample S; +extern int nb_tours; +extern float epsprime; +extern bool verbose; +void genere_aleatoire_unique() +{ + int nbetats; + int nblettres; + int numgraphe; + int nb_succ, nb_init, nb_term; + PFA A; + + cout << "Nombre d'Ètat : "; + cin >> nbetats; + cout << "Nombre de lettres : "; + cin >> nblettres; + cout << "Numero du graphe : "; + cin >> numgraphe; + cout << "nombre de successeurs par couple (etat-lettre) : "; + cin >> nb_succ; + cout << "nombre maximal d'etats initiaux : "; + cin >> nb_init; + cout << "nombre maximal d'etats terminaux : "; + cin >> nb_term; + A.becomeRandomMax (nbetats, nblettres, numgraphe, nb_succ, nb_init, nb_term); + string fichier_ps = "_tmp.ps"; + string fichier_tmp = "_temporary_file"; + export_to_pdf (A, fichier_ps, fichier_tmp); + show_ps (fichier_ps); + + if (A.isPFA ()) + { + if (A.isPRFA (true)) + cout << "is PRFA" << endl; + else + cout << "is PFA" << endl; + } + else + { + cout << "not PFA" << endl; + } + +} + +void proportion_PRFA() +{ + //------------ Proportion de PRFA ----------- + int max_nb_states; // max number of states + int nb_try; // number of tests + map < int, int >Tableau; + map < int, int >nbPFA; + int i; // taille du tableau + int j; // nombre d'essais + int nb_moy_succ; // nombre moyen de successeurs + unsigned int taille_auto; // taille de l'automate + + cout << "Nb d'Ètat maximal : "; + cin >> max_nb_states; + cout << "Nb de PFAs par taille : "; + cin >> nb_try; + cout << "Nb moyen de successeurs par Ètat et par lettre : "; + cin >> nb_moy_succ; + for (i = 1; i <= max_nb_states; ++i) + { + nbPFA[i]=0; + Tableau[i]=0; + cout << "\ni = " << i << endl; + for (j = 0; j < nb_try; ++j) + { + A.becomeRandomMax(i,2,0,nb_moy_succ, 1, i); + taille_auto = A.size (); + if (taille_auto == (unsigned int) i) + { + if (A.isPFA ()) + { + ++nbPFA[taille_auto]; + if (A.isPRFA (false)) + { + ++Tableau [taille_auto]; + cout << "R" << taille_auto << ","; + } + else + { + cout << "P" << taille_auto << ","; + } + } + else + { + cout << "X"; + } + } + } + } + + // compte rendu + cout << "Nb d'Ètats\t% de PRFA\t(nb d'essais)" << endl; + map < int, int >::iterator t; + map < int, int >::iterator nbPFAi; + for (t = Tableau.begin (); t != Tableau.end (); ++t) + { + if (nbPFA[t->first] != 0) + { + cout << t->first << "\t\t" << (t->second * 100) / + nbPFA[t->first] << "%\t(" << t-> + second << "/" << nbPFA[t->first] << ")" << endl; + } + } + //---------- Fin de la procedure de test de la proportion de PRFA + +} + +void prefixialisa_echantillon() +{ + string ficin, ficout; + cout << "Entrez le fichier echantillon : "; + cin >> ficin; + cout << "Entrez le nom du fichier de sortie : "; + cin >> ficout; + cout << "load en cours..." << endl; + S.load (ficin); + cout << "save en cours..." << endl; + S.prefixialise(); + S.save (ficout); + cout << "Voil‡ c'est fini" << endl; +} + +void Choix_cysteines() +{ + // = 1 ===================== on entre les noms des fichiers + string nom_base_pos; + cout << "Veuillez entrer les noms des fichiers de pfa,\n"; + cout << "de l'echantillon positif associÈ,\n"; + cout << "de l'Èchantillon nÈgatif associÈ,\n"; + cout << "et enfin le nom de l'Èchantillon test associÈ.\n\n"; + + cout << "Finissez en entrant le nom ." << endl; + ; + + map < int, PPRFA > Modele; + map < int, Sample > PosSample; + map < int, Sample > NegSample; + map < int, Sample > TestSample; + string nom; + Sample S; + PPRFA A; + cout << "Nom du fichier pfa : "; + cin >> nom; + int i; + i = -1; + while (nom != ".") + { + ++i; + A.load (nom); + Modele[i] = A; + cout << "Èchantillon positif associe : "; + cin >> nom; + S.load (nom); + PosSample[i] = S; + cout << "Èchantillon negatif associe : "; + cin >> nom; + S.load (nom); + NegSample[i] = S; + cout << "Èchantillon test associe : "; + cin >> nom; + S.load (nom); + TestSample[i] = S; + cout << "\nNom du fichier pfa : "; + cin >> nom; + } + + // = 2 =============== on calcule les moyennes et ecart-types + map < int, float >moyenne_pos; + map < int, float >ecartype_pos; + map < int, float >moyenne_neg; + map < int, float >ecartype_neg; + Dictionnaire dico; + + map < int, float >probabilite_pos; + map < int, float >probabilite_neg; + map < int, float >::const_iterator prob_it; + map < int, float >decalage_pos; + map < int, float >decalage_neg; + Sample::const_iterator w; + + int j; + float min; + float val; + for (i = 0; i < (int) Modele.size (); ++i) + { // pour tous les modËles + + Modele[i].lisse(); + + // 1a - on calcule la probabilite minimale les mots positifs + dico = PosSample[i].dictionnaire (); + j=0; + min = 1; + for (w = PosSample[i].begin (); + w != PosSample[i].end (); ++w) + { + probabilite_pos[j] = Modele[i].plog (w->first, &dico); + if (probabilite_pos[j] < min) + min = probabilite_pos[j]; + ++j; + } + decalage_pos[i] = min; + + // 1b - on calcule la probabilite minimale les mots negatifs + dico = NegSample[i].dictionnaire (); + j=0; + min = 1; + for (w = NegSample[i].begin (); w != NegSample[i].end (); ++w) + { + probabilite_neg[j] = Modele[i].plog (w->first, &dico); + if (probabilite_neg[j] < min) + min = probabilite_neg[j]; + ++j; + } + decalage_neg[i]= min; + + + + if (decalage_neg[i]second - decalage_pos[i]); + } + moyenne_pos[i] /= PosSample[i].size(); + + // 3 - on calcule l'ecartype pour les mots positifs + ecartype_pos[i] = 0; + for (prob_it = probabilite_pos.begin() ; + prob_it != probabilite_pos.end() ; ++prob_it) + { + ecartype_pos[i] += + pow (moyenne_pos[i] - exp (prob_it->second - decalage_pos[i]), 2); + } + ecartype_pos[i] /= PosSample[i].size(); + ecartype_pos[i] = sqrt(ecartype_pos[i]); + + // Maintenant, moyenne_pos[i] contient la valeur moyenne de la probabilite + // des mots positifs et ecartype_pos[i] contient l'ecart-type des mots pos. + + // puis pareil pour les nÈgatifs + + // 2 - on calcule la moyenne + moyenne_neg[i] = 0; + for (prob_it = probabilite_neg.begin() ; + prob_it != probabilite_neg.end(); ++prob_it) + { + moyenne_neg[i] += exp (prob_it->second - decalage_neg[i]); + } + moyenne_neg[i] /= NegSample[i].size(); + + // 3 - on calcule l'ecartype pour les mots positifs + ecartype_neg[i] = 0; + for (prob_it = probabilite_neg.begin() ; + prob_it != probabilite_neg.end() ; ++prob_it) + { + ecartype_neg[i] += + pow (moyenne_neg[i] - exp (prob_it->second - decalage_neg[i]), 2); + } + ecartype_neg[i] /= NegSample[i].size(); + ecartype_neg[i] = sqrt( ecartype_neg[i] ); + + // on a fini de calculer les moyennes et les ecartype pour le modele i + + cout << "µ pos : " << moyenne_pos[i]; + cout << ", sigma pos : " << ecartype_pos[i]; + cout << ", decalage pos : " << decalage_pos[i] << "\n"; + cout << "µ neg : " << moyenne_neg[i]; + cout << ", sigma neg : " << ecartype_neg[i]; + cout << ", decalage neg : " << decalage_neg[i] << endl; + } + + // = 3 ==================================== evaluation + + double p1, p2; + bool res; + map < int, float >probapos; + Word u; + res = 0; + i = 0; + for (i = 0; i < (int) Modele.size (); ++i) + { + u = TestSample[i].begin ()->first; + dico = TestSample[i].dictionnaire (); + val = Modele[i].plog (u, &dico); + cout << "val = " << exp( val - decalage_pos[i] ) << endl; + if (moyenne_pos[i] > moyenne_neg[i]) + { + p1 = fonction (exp (val - decalage_pos[i]), moyenne_pos[i], ecartype_pos[i]); // ECRIRE fonction + p2 = fonction (moyenne_neg[i], exp (val - decalage_neg[i]) , ecartype_neg[i]); // !!!!!!!!!!!!!!! + } + else + { + p1 = fonction (moyenne_pos[i], exp (val - decalage_pos[i]), ecartype_pos[i]); // ECRIRE fonction + p2 = fonction (exp (val - decalage_neg[i]), moyenne_neg[i] , ecartype_neg[i]); // !!!!!!!!!!!!!!! + } + cout << "p_pos = " << p1; + cout << ", p_neg = " << p2; + probapos[i] = (p1 + (1 - p2)) / 2; // ??????? + cout << ", probapos = " << probapos[i] << endl; + } + float probaposgenerale=0; + for (i=0 ; i< (int) probapos.size() ; ++i) + probaposgenerale += probapos[i]; + probaposgenerale /= i; + cout << "probabilite d'etre positif = " << probaposgenerale << endl; + +} + +void Apprentissage_unique() +{ + string ficech; + cout << "Veuillez entrer le nom du fichier contenant l'echantillon : "; + cin >> ficech; + Sample S; + if (!OK (S.load (ficech.c_str ()))) + { + cerr << "impossible d'ouvrir " << ficech << endl; + throw 5; + } + + PPRFA A; + string reponse; + unsigned int seuil; + string str; + float tmp; + float precision; + T_ModeReturn moderet=begin; + T_ModeEpsilon modeeps=epsfixed; + + int max_etats=INT_MAX; + cout << "Les parametres necessaires a l'apprentissage sont : \n"; + while (reponse != "0") + { + cout << "1 - La precision .................. : " + << precision << "\n"; + cout << "2 - Le mode de retour ............. : " + << (moderet==begin?"begin":"end") << "\n"; + cout << "3 - Le mode de gestion de epsilon . : " + << (modeeps==epsfixed?"epsfixed": + (modeeps==variable?"variable":"word_variable")) + << "\n"; + cout << "4 - Seuil de suppression des aretes : " + << epsprime << "\n"; + cout << "5 - Verbose ....................... : " + << verbose << "\n"; + cout << "6 - La taille maximale de la cible : " + << max_etats << "%\n"; + cout << "7 - Nombre de successeurs par mot : " + << seuil << "\n"; + cout << "\n"; + cout << "0 - Debut de l'apprentissage\n"; + cout << "\n"; + cout << "Votre choix : "; + cin >> reponse ; + + if (reponse == "1") + { // precision + cout << "nouvelle precision : "; + cin >> precision; + } + else if (reponse == "2") + { // mode de retour + cout << "mode de retour (begin|end|b|e) : "; + cin >> str; + if ((str=="end") || (str == "e")) + moderet=end; + else + moderet=begin; + } + else if (reponse == "3") + { // mode de gestion de epsilon + cout << "mode de gestion d'epsilon (fixed|variable|word_variable|f|v|w) : "; + cin >> str; + if ((str == "word_variable") || (str == "w")) + { + modeeps=word_variable; + } + else if ((str == "variable") || (str == "v")) + { + modeeps=variable; + } + else + { + modeeps=epsfixed; + } + } + else if (reponse == "4") + { //seuil de suppression des aretes + cout << "seuil de suppression des aretes ([0;1]) : "; + cin >> tmp; + if ((tmp >=0) && (tmp <= 100)) + epsprime = tmp; + } + else if (reponse == "5") + { // verbose + verbose = !verbose; + } + else if (reponse == "6") + { // nombre maximal d'etats + cout << "Nombre maximal d'etats : "; + cin >> max_etats; + } + else if (reponse == "7") + { // nombre de successeur par mots + cout << "Nombre de successeurs necessaires par mot : "; + cin >> seuil; + } + else if (reponse == "0") + {} + else + { + cout << "Choix inconnu" << endl; + } + } + + A.DEES (nonconstrained, S, precision, epsprime, verbose, moderet, modeeps, max_etats, seuil); + string ficffaA="test/A.ffa"; + if (verbose) + cout << "saving A in " << ficffaA << endl; + A.save (ficffaA); + // affichage de l'automate + string ficpsA="test/A.ps"; + string ficdotA="test/A.dot"; + export_to_pdf (A, ficpsA, ficdotA); + show_ps (ficpsA); +} + +void makePTA() +{ + string ficech; + PPRFA A; + Sample S; + cout << "Donnez le fichier contenant l'echantillon : "; + cin >> ficech; + S.load(ficech); + A.becomePrefixTree(S); + string ficpsA = "test/tmp.ps"; + string ficdotA= "test/tmp.dot"; + export_to_pdf(A,ficpsA, ficdotA); + show_ps(ficpsA); +} + +void TST_FD_BD() { + string ficpfa; + cout << "Donnez le fichier contenant le PFA : "; + cin >> ficpfa; + A.load(ficpfa); + + Word w; + cout << "Donnez un mot : "; + cin >> w; + + list F, B; + A.logforward(F,w); + A.logbackward(B,w); + + list::const_iterator f; + list::const_reverse_iterator b; + PreciseSFunc::const_iterator x, y; + cout << "P(" << w << ")=" << A.p(w) << endl; + for (f = F.begin(), b=B.rbegin() ; f != F.end() ; ++f, ++b) { + for (x=f->begin() ; x != f->end() ; ++x) { + cout << "F[" << x->first << "]=" << exp(x->second) << ", "; + } + cout << "\n"; + for (y=b->begin() ; y != b->end() ; ++y) { + cout << "B[" << y->first << "]=" << exp(y->second) << ", "; + } + cout << "\n\t----" << endl; + } + +} + +void TST1() { + S.load("sample"); + SFunc solution; + WordSFunc XR; + XR[""]=1; + XR["a"]=2; + XR["b"]=3; + solution[1]=0.5; + solution[2]=0.5; + A.becomePrefixTree(S); + SFunc Iota,Tau; + A.allStates(Tau); + TransitionFunction T; + A.allTransitions(T); + A.BaumWelch(S,T,Iota,Tau,10 , false); + float x = S.AutoLikelihood(); + float y = A.Likelihood(S); + A.save("test/res.ffa"); + cout << S.size() << " "<< x << " "<< y << " :: " << (x-y)/S.size() << endl; +} + +void TST(){ + string entree; + string sortie; + cout << "Echantillon d'entrée : "; + cin >> entree; + cout << "Echantillon de sortie : "; + cin >> sortie; + Sample S; + S.load(entree); + S.save(sortie); +} + +void TST4() { + SFunc solution; + SFunc Iota,Tau; + TransitionFunction T; + Transition t1,t2; + float x, y, x1, x2, y1, y2; + float xsum, val; + int i; + + S.load("sample"); + solution[1]=0.5; + solution[2]=0.5; + S.prefixialise(); + int nb_sucb=S["b"]; + + cout << "prefixialisation..." << endl; + S.deprefixialise(); + + cout << "becomePrefixTree..." << endl; + A.becomePrefixTree(S); + A.save("test/pta"); + + cout << "becomeQPFT..." << endl; + A.becomeQuasiPrefixTree(S,"b",solution); + A.save("test/qpta"); + + A.allStates(Tau); + A.allTransitions(T); + + t1.qdep=t2.qdep=1; + t1.a=t2.a='b'; + t1.qarr=1; + t2.qarr=2; + + + A.BaumWelch(S,T,Iota,Tau,30, false); + x1=T[t1]; x2=T[t2]; + xsum = x1+x2; + x1 /= xsum; + x2 /= xsum; + + A.BaumWelch(S,T,Iota,Tau,1, false); + y1=T[t1]; y2=T[t2]; + xsum = y1+y2; + y1 /= xsum; + y2 /= xsum; + + val=abs(x1-y1)+abs(x2 - y2); + + i=20; + while ((val > 0.001) && (--i != 0)) { + cout << "."; + x1=y1; x2=y2; + A.BaumWelch(S,T,Iota,Tau,1, true); + y1=T[t1]; y2=T[t2]; + xsum = y1+y2; + y1 /= xsum; + y2 /= xsum; + val=abs(x1-y1)+abs(x2 - y2); + } + A.save("test/qptafinal.ffa"); + + A.save("test/res.ffa"); + x = S.AutoLikelihood(); + y = A.Likelihood(S); + val=abs((y-x)/float(S.size())); + cout << S.size() << " "<< x << " "<< y << " :: " << val << " " << nb_sucb; + cout << " " << val - 5/sqrt(float(nb_sucb)) << endl; +} + +void TST3() { + S.load("sample"); + A.load("test/tst3.ffa"); + TransitionFunction T; + SFunc Iota, Tau; + A.allTransitions(T); + A.allStates(Iota); + A.allStates(Tau); + for (int i=1 ; i<200 ; ++i) { + A.BaumWelch(S,T,Iota,Tau,1,true); + cout << "." << flush; + cout << "\t" << A.Likelihood(S) << "\n"; + } + cout << endl; + + A.erase_bad_states(); + A.save("test/res.ffa"); +} + +void TSTprime() +{ + + string ficech="sample"; +// cout << "Donnez le fichier contentant l'echantillon : "; +// cin >> ficech; + S.load(ficech); + + float precision, epsprime; + + cout << "Donnez la precision : "; + cin >> precision; + cout << "Donnez le seuil de suppression des aretes : "; + cin >> epsprime; + cout << "Donnez le nombre de tours de BM : "; + int nb_tours; + cin >> nb_tours; + + A.DEESBM(S,precision,epsprime,true,INT_MAX,0,nb_tours); + + string ficpsA = "test/tmp.ps"; + string ficdotA= "test/tmp.dot"; + export_to_pdf(A,ficpsA, ficdotA); + show_ps(ficpsA); +} + +void proba(void) { + string nomfic; + Word w; + cout << "entrez le fichier : "; + cin >> nomfic; + A.load(nomfic); + cout << "entrez le mot : "; + cin >> w; + cout << "p(" << w << ")= " << A.p(w) << endl; +} + +void +Y (void) +{ + int choix; + cout << "\t\t1 - BaumWelch sur test/tst3.ffa\n"; + cout << "\t\t2 - Probabilite d'un mot\n"; + cout << "\t\t3 - Prefixialise un echantillon\n"; + cout << "\t\t4 - Choix pour les cysteines\n"; + cout << "\t\t5 - Apprend ‡ partir d'un Èchantillon avec optimisation du paramËtre\n"; + cout << "\t\t6 - Apprend ‡ partir d'un Èchantillon\n"; + cout << "\t\t7 - Cree un PTA ‡ partir d'un Èchantillon\n"; + cout << "\t\t8 - TST\n"; + cout << "\n"; + cout << "choix : "; + cin >> choix; + + if (choix == 1) // Une generation aleatoire + { + TST3(); + } else if (choix == 2) // Proportion des PRFAs + { + proba(); + } else if (choix == 3) // Prefixialise un echantillon + { + prefixialisa_echantillon(); + } else if (choix == 4) // Test pondere "intelligent" ? + { + Choix_cysteines(); + } else if (choix == 5) // + { + cout << "Ce choix n'est plus valide !!!" << endl; + } + else if (choix == 6) + { + Apprentissage_unique(); + } + else if (choix == 7) + { + makePTA(); + } + else if (choix == 8) + { + TST(); + } + else // mauvais choix + { + cout << "entree inconnue" << endl; + } +} diff --git a/lib/liblpsolve55.a b/lib/liblpsolve55.a new file mode 100644 index 0000000000000000000000000000000000000000..9821eaa0502e958d11687a684c219412ebeb2299 GIT binary patch literal 857640 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 z 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.ZkeehNR>2Mwu&zsK{h@p5%( zKf{lYJGk=BqRwT-7t?p6I~}q*1W)lg+BI}pbeuJ|?deGmCe@i6Lfz`qqfO8jqu1zL z^{wyIcN+TZ#8k6?&3V@0;`Z!Sz~ltFc?f>8G}!>l48Cccdy5;uX+JpFp8cSM-zA#j z%C+KQ(zDBTB+*^$d}q_o;j>lSYV_x%ujwU6=e;pn%ywy=>o^OpUOj?7T&X=3mdy#? z-KG8LYeDA~d@m%UvS!)lgntR_^-$Xunxj@5|@}z#BY57hHDJ&X=4qH*yDo-T7K% z>b`@Y^vLJmrT3X@;XT;wszirqqdPOBlzT<~-Cfythk7^%u35$Qw1dGx!*iB?Bs%Kn zY@c_sJMq5SrVQMVs9bHNw`ngGpA&uxp2CI9O4_Obzo{cQ2)_DFeAQZG=wJf44_OJ> z+!pf89@H6hwf2i?!(1CjRo8w=1M%@^nH&1x0-oDpR}K8GeX${ z`K^_;Ut`(_4k~|(_M5%-4g5awJK#5c3jD5i;Me{$?6d4KwV!AHcJS80tn&`oIdd}Q zp<4$tw2?OUlqv9AL0f$5<;?q?@B`*0_`$!+`;fg;ur&R!Ck^}<%kP4p=!)7a!Ed7d z8p#Kf+IL}D)_$|*s`gzxtH!s3d?4HvL5>Xam>7JZta@sh_KIXqod-#V5Z=lz!8*iD zo)7p5vQ2|zSL!vk`=QMnurXg_eKv*fBRJhGIez2@WOV=X1x4_My^n1tSwH?ss~#NR zhm3!`2)@E=bK?oC?HF|_f6Vd8wW9iVJkjQrhxNZ{bIbAtg^N0`E=n$eb`+{gZMGG{ zRmfhpy(JLmn$8o}w_D61Hm=DR|GqI z*9W^f%h+HaI~BDLzCs*Auq$;-BAQyXFq-~)V1UB8`smW&r0NOvz8g&b-$I!`)L#>^VDbH~B@ zreSM3GIgvu@$rwRt@GWTOF#Z+c1PsD+e_chd1j=o=^1?D&i&#C_MFFmklxLA;I-Oq ziW&M~o@H~^|A~8iFJx@&diXA_zWJT!HP^%t=SfozvY!+Vje5syeHtvzI@B-o+lxuEUpV zdPjq8t>Ap@riP`&*g&(7tDf4qmObIMr81r)rd@p844mHant>DjL~ZN!s9@v3t$0>r zLzYvHqy_p`W6b^~w5Xr>c*cirY}wY$QTZTcK8g%qeMvNN*jm6he!KEa+p4S4@7ytK zoT;mC#wVK?u6H2gF;;lEeECjhn;C00m#03%yokM0jF;A(F)h%%;rqd?%~(W}`V$th zZB>dfll+q5jKZ$`uxU%Ov6(maS>ZGH$^?bePY4fP9Y*}Y$a0d+b^p@Wad~^PP@hP z>6fb8R__B2Tk$vL{)N@wmcQfT{YEDpGIU1%t`>U83p$I>@yxkjkaetK9Z$J%h{%Ug z--{nh$I!eye;DmObaIoM$;fO0C#RQm1I27%A9;bz6iIEkS+P<<`H!snB(kButs#3o z=Xvw|>2HYtL9N&Idf2LPNpN%I?8DsxaD{Ck|_J;QpL2fL|3)TcT>I}@HLIm zgS%%dX*q1w$p=&IZ|6ivG(}@B_m5P}sG&7OtlM&A1^Huby(B8U_Tv0fb&U=21bbrN zd$6-C9JD_)&x~2?ZpO}@Zh#MJ4&ptE2bE8v(K}opWG^S8^bqW1xt837Jr3Mc{IO5x zbn*SI2jj+XXz?SoFFE6ocp!CTzZ*?E&rW@Ony5eO)>r;A)!&ZKBQOp%=a*UuXxop~ zUm<4YWS=%?gmCzKOlkbv>TJIH~HvZ7VW-W{l zFtErP{LNS!@QbfA_f`4PX^Dv`Z_~6>S=MIdb%)UXW9_%2!*Y*`kpa*d)jsR_*>d;_ z_mjQ_)hg2(X+OxOl&`(+Id5N-@Kbgc{9_G%PMpyV#9y(R<4y7a2>=6$P}gF|zs*n@2L8E5Fv>+D?nOL!wXs(FAf-8x6t93ufTjO;$i7jg67f0MnlBI4l2qLxJiiuLzfcMpLZn)i@n!*g(BMclmiExHVR zJKlhf${tfLLC3#_^W6y_g%8Zsc^%(bo4@@{Xz2K5)Qt%qql=_tEZ(*bk%Wb^jdI+%={nCl>E(O1$;BfR&MPf#1U#i~7|V)VKPj&)LQ7 zIl-@fv#NVTuYcS5^8Gf{Qp_9rhOS`t+b)OqYfZsf z^pU^|TYeO3)}D|If}VO-a!`Dkb6)107j@}fSaXuyOlN4yZ>#gN%;oqs05|7*U%ZKL znSOB5=b)9~rSMR9ylp=G4RG-{U&%+&tDXp*WnYpLmUF?Zu^XSv{%6jFR^yM+fj>sv z^~d;cQ~WW8@yFPLKSrOm@7lisSNp6!JL&jkEP4iG{>$LhBIqVKm2ZZRl;IWYXZAqe z--Lb5;C>bBmSbJQg;=;vV@<#72z=>U^7}etG`?Ta;NX<8&QITafHf-?kr9Keq3*J) zmQP6f-rce(D^@A2`5L(gyI1pg4LowoO&QB~Wa&cD zE5$`~Mm6TymgB{NbGhO$f0=XOkbnD>{}Q*t4DUp2Q*YCUfRm1ea+iik-BoIMAg%Rb3pga>eXXuf4j7?~a-ZNQ`Nd>!-awrjj|T-pE5fM2I_f}_?Eno)0Lw=Hkx zm*sVfdkha^O@qWh2F{8M#|H~@tgG$HmyB;N z^_tTsULvkjxCFh&hqc&ezUeUIb@v1NwVMBl6F)v!%#5+FhOSnrEVY+1ts(ePsF9z> zkDN8nd`9vodKrDz7~36oy>o5$^079?opkJWRaFyvMs${6 zpJ>JEXDXJs^n#o@?|x1HLst)!#lRgrB07qkdIUOp1R8n-`YFFQ&!qQmcWDha&yl_F z+pV1I+Gp~$$-Ip2{gTdnuKEf&34Z0u!W)3|3#`Wid-gt2&3hlGJCI-e;!ET30&H|3Tv zaHD2jurJ zye$q#a_I};t`lFjWWF=+Yux+?z6Aw;xL)#RNycRE4lEka8o1#{TpWvtpUf|Afmcn6 zxm(iaw&&&lJ}JLt&0n~TZM!YK&mS$`XK=ErIA&;4Yf1m(9Ip^NmlGe>-b(teNP)}E z1{c^rnv?MpBM!juLE1fXqEWu^Vf9h$H#DuPIBfXcva)vLh1i+$cCYl>9ogdS%e=qw ztaC`XVy@qoe1Echl{%GNvaD(JQ z)je{e;S6hG^n9MrnfN-^GU=Q9E%A%Ob?AcdjM2sD_27fUJJ5H4r{Kt52x<=)`pjI! z1HAcZ>=l_n=)gT! zg#MKAzCFjYXYcdkU+H6 zE}5;s|K>}%`0c7`kt{DR%fc?ig`{yM9$jlfd9xf8T0$lHQVIJ zkgma}`Td-yxXdK(2HL&azzhqB+Ps9 zvqR3Am2AQJ+G}#spV+4}^Rw|~oO|l(ktZvng}DJ+YpidyH@&v`cE0dr^0&3eoNrED zou8vN0-qmUf*vOM;$_Jf%oqCs^R3F<5|Gc{{LCzO|M3gnWYSll%ZaB0^OAn<$`R7h zC&?1nzlbp;afkLJepQ}7!zQf(XGAe#J{!}SYGZ$qZZu)fx$0xa9;AGQn?v#R z9#cp8gO19lyR6<~Xvi}8?FioBpS9a>-Cj;Vv|ofz^l5d1|JvKy1G4p-IcdC858-d6cqe>_u6$JEW4z*Zu8$M+m3`>$sYdpK z@dbhwY*^)oCQw&r9`d!Ze@2cV?b&T+KaBD0_=w5(Fd-Qt)S6m8r#m&zw`)}l8>!BP zIIp%>CPg>#gQ~#SbJ}@(xx2Uc-rZYy7ao^r-kQH`(q`^cY<=v_I_)i;>zniZ_2iTQ zHpZraty(n7es`<%K|lKipPJBoc-isPozk<`89yBtzw4ZH@vEB+FK2H_XDY-xuNIw7 z`rdI;{?le(L&N`&epBBl_3QWm*Uo#s_?58MeLiiqvCfhM=X17xTs}Sp3p-1u)7x(m z=xDv$cNgPm^ZLdnKK8r#yyR3v=PtnG9r^SF&pSN%%0GAbi7)Q-Q!|%!F?MJ1RRcrd z=fZBI#%FjczD=(Fsr)VTS7WQA9sInF?!sM4p_r}o*;ME_v zMn2`Pdy6%C*JI<`!}Xf)?^vT@hqu3r`yCBG2!k)^gW$p+v~K7AL+d7-GV6AP{@=82 z?|;zPv&_2H5+C%(uUknz!{4A>KJ$Ex6GM)kz}jGMThN&F)y@+<^0ilm+0)(lH^|Pa z`&ZWRYzqWiQFO6f?o)iH1h~E9^cs`9Q@c(LZmGxcj&bIyC9tKFKvx z$Hp8Yi?3!pl~=AYWBY{m^p(UPSfAw%z)iFtQ`_`GnZHC^`Och^xjfIg7cfElmCoF? zM~%;{+NaHtZ#eB6->AK6A3A&yG2XN*`OEO8KC7ECY#7gk+ZJ{jSRyZlWEVd!Kg=op zSBbXho#^ca-iPgZ>}}eX4;r@faQbe;(++SK*KyI^mM4n4%lesbeAUo!^n#-pLrotRJOoqw5oSUu1KEnL)$H*Bw^^nzh z?QZ@*>}%}33?D(B6Njx~o!Ll6X&PocH<5d;>Fl6$t~=)DTmmkNW&iPp5YuwN@WS=U)6{r{DhKF!S@#?g9A~ zv+3$*<)wJm)}?aSt`KCts2Voe5|w$G1U7)CX(UKmFI z>0-f1ZI;0)PkU`8+OPHXWU(z1=hUJh<+P)8MvdHuu3~I8_6IM;R?`@BX#8w1|Hpjj zLAAXPT=_O}i2tWaXM>LepD1!$v*a=D&7`mDjSKC4;heFDvCdjYPbQ=d6R#;+Q5r9G zr`l)OPdV?KsWJqzx-)L%q4@r5bMCmW5q>hhGp>9!iH^JpryaT1@Rp_l^IfaxqRG>N z+)~cZXwT>ddH>vH#*dIQ&+&|vlYBEiVC)2u@l0o%^Z&X?ehKgDlEajXvtZzTDpB z>3Sag$Zf52W6^?p=sV)tDf#~;bN{VpcPw8I(d=^E(HcmmckMO1jK5r;wH=t1?!g02 zjlY+cIB<_Kj(7>)7d&@+=diKqpqmt82FB*xP4g98%6SbqcvLn=mB;rt)H(Pt%j9=a zJ%=a0b6E2ee-a(lI1P?&wT^18qWj`c?OUDmP-GaxAB5xO{3p$+w0z8Yf9@@KSRMSw ziSzT%k&apA@Txf{3;3XjKV5(?)$1F>bMAJ&F+69BzUgX1wsd&T^`RQKt<#FpGqGw$ zKj>=1PaWOAFk7 zR!hG>*ub2zJwy!uBsN=X+jN`N+Qb>xHR8K}h5ygx?%6i}80fU4#$HIwOnlfo(|pGl z)kbF4qzR;!)rc%xorK!B)}T%Tgv+6n=WNZJB=XWlH)Y zH@Ih_*a#|e=DZO2Cw(&?(LOlx%xrvZeFvJ0$V^K@r;q$(cDpSi^hzkcYH`6cYk@*ktty`Zp(ESJaU_%NzIM)imJRN>&Fb8d zwKj}otxoM1gX4#Y`+C``SDZrnt~m6#_;AZ#vo2p?45hQ;i{CKouQB|UwLA0q(!1?R z-^ItwJJyswjeofVKdW1C(OAbb{Ibucju$+hFIbIyZFbxnqhv?v)#6{pe){8#i*}=K zy+-&sHgPMbJ?P|mFOs{&@c04Qh(*h=BfU_vBZ2eM^HR5EW7>Y;$wQ%1+_T$7Uyo#;mgA-@0 zHg{qex`WMYe4sPO_`|Zp3dWqRUhT$t9H9I`@eIkx%+vL?y1be4oNS83qQ+QrV=LEs z=W8!-X0AQLQS3Tl{jYM#0r@bvK$#mSIR8T9GH1WgHTtSH^xn@rvh+}q3&=Ga$;spSJw()3>Oo^q zY0qN6H#YIwj)u$(e6{CI81n}Le z0=&u&n_R#KSJGc@)85`j-+zeAw?=1*vJoy^$3Dw+2uG5O!Mj!XEslKsvY_b?-OXNp z$po+DeSZ37^2;*3QhQW9SKmwblHQV;6Fit%OOBq(KstlXwq>uiU4AZtCpfTxHHB^m z-1R5Fy~Y6C^o@KsGAB&lC!O6TRVJHe7N2y%O!i30q{!@H+gcP=Ui^jdc#So^tKUTz8Q<~79FmuDdV)OeEi-y ziF`%OImz5}_)dhgBmJR*&b}P^)`4018I{gn?8WG^w42V1X?;W!Ob%{-O{@w0yxY(; z_FegTiuR&s`zY64BrhU2R7+MExgt~;ftMILtrA)W9Lx3i?g4UGuB=$np82=)?OT3w zK82j1*ou+$75k7W{!(M$xo^Hj8`wSCw@&-ZYgtd^8$B-|7hecka+ZDN<=*SNK<>S2 zKCkCbY~lcahxp6Sznk$r5RB07Df)SyG1r)~y(TByX+5`m$ytYyy)(B{$N1!qJT!9` zvf)3bQ+{8F7QWp(bHxeIx$9^D~1-r5m|ruF@fdd5~W-fF#KLwlxK-!^DBHXXf)P`dAw2og@JUyfmMje3 zc{%h)r{vHt<;-Uc5#>Yha_XZaACio5BYuR$Fa))?6m!h8Q-@#i?5A3YwdkA3izGi_ z$*<^I1KhE5l(p767`qg>9@g1Odcz5m!=>p(>?nIe!=;?r)_Ie^mwL~c+%9`U`LcKa z=*m0~s?2@=ocI#@(`)X#?TTxGMkMf$H{%E9b>yxdm28?{96GD-u%Eo57^oa|n0K}K zM$#%gf?vM=59>GMH@Qo&k8<|_&y+6^-v^hJFTGyvXZ8fn01uPT+>vRgzpD3YLpaBJ zICgEp$g^#TPwRi=ddcq|tYnjbuAjL;zVs@S|9nqO`gm9}v*aY`D00DXf30tjL7R!! z5NY)K`L*`xH4)_` z+M4MP=8f*$kBw_{@F@KSO?>ZR@?8-tmGp(Kxz;JmiI1|sTd7lT+tqEFyK=3&-{klvU{_u| z$TzxQ!JI>Rx!+b6`%Eq~>MH-f^rL7z#aVA3=go)AU1ug1%Zqg?kH>-zl=8l^mq(?$ zm-KaP)7sOnUkE;pod2=c!L4TT0DeVBbcX86F&ByE)El3(kH3ihrzQ-&B#&|BY?p6s z6E8S&;-cr=^;WJw3mJzs{|&Nm2{*#MTdZK=ozwn~vSGUPjaO-cDX!qhjXrXE9ZISM6*-+Ef$R5%I45>qG#!K;DRUXFy9NE(RuQYy=Ag5 z&V>B|Irss_3JnDYkqqbNdIk=jZw_Zbv*sh4UFpudCes_r%XTiGM#VuVeHF_!o(u6g zcw7~7%4y*Qx{isVP%Jxrg)@pfTz`ql8*FSkvbo$=JZ)?(ZrqqzGso64AiAt^8#@X2 z3Yz^kR6fqj`;xwCZv2<8-KB@!^xr6)PjFtP@t{|0EY6s8-=cMi8BbQ@S?Qk%e~gvI zA@>OYM4bo#G+iwUT2Qa^Dgf0H`?HS8t{X0 zY-Np|am;bYvG#)FAm({eJoJ2T9PGz3f5^-8;3hgiMb=%T4rh!<;VY&7<6i%aYd-dh zDl=xr>y9->-Db0nOPR|Wv-cuyd!AhF@J-gpvlW!bgD93wYp2*gqvw*x)8nHazD>rf z%g_NsuKy!3S6S>o1K|Cz_RzRT3;xMwld_#C|&TO_8&!PW-cY*Jkz31_B`Y-3_ z_V30gV`n$``uyXx=af5hZq}SB|1oVk<@g~{KjD@Oe%gDE z&QrcN>mB=z&OnFeg-;HTQlKnFvb5x zI8|mZIpEThGcG+j-TMGCH2YWd5}1aumsO=|{knJaVeoyE*0klYH303Mti!Wk96O7% zj$PP3oi#euVq{V4>>DOlS#qgWn5R9GNm(&qQM)@UnI4nLE-%K2w zq2cH6;Q2JqXOh!B&Y!O*t5`7Nhy#BbZv{ZY3r_i|05E7kn({t$oDtNpO5ieo3wuU z70sD-i0Ir{cnIvOnx19cx14E{4AXQ!{)6}N|7>KQtur?onl-?lvVQTX>67?d2j_k} zx7pfwd#AO|vS(k`VB&}!{9Eq6H#tO&j*{XI%k{-^+UrhQuT{G3M4GLJzv#3+!}qT> z=o`k!TE1~-(=a}j?8%%xtqWW^sPXXaCh+qj-ud;;+!bL@>*oD#(ObS%p41TZE37zl z>IIcsz~ud)e#;OvhxXjIwkECdr}a!98)-YIca%NimTjVJz%9EcQ!{NN^$ZWEzdHW! zc5$CBxmFx{*Ni`|X}1K*sI{?0eUd^5}$LY4PTdHo&Kr|u!f z5YQOhZ;tZKQEY2E&olk#`>fxJO#PPJe97D^Mjq~Qzdgmbr?&lp-|lw4ZT4W`wDETC zrR9(Q%KN`i--eb8Zu{RJ)!iSgYXIH^9-sfPW9zu@JoBrUtpj+XM;8Zx?_)d%@K=cP zOMIZoQ^*~7zBlt3{7s#`S7Bn;SkFje2;AwkoU^=6H$Q-A*<0~s_GW1>20{rJ7sBk3 zpJ!~^6~56fW1g)&m8+p_mPJl3^g5o^mqVw*UE))MQD*78GXJHTGl6;U>dvjH7*jcA ztvi}4PU<~nr&Y%L0m^ffpK;2kHM->oC~u_vtXuz_TmCTRHsuAkzU7v0r982td7816 z=hjR!X9l!?kn&E-V{UyDUqJaT%Acpa&Mi0o0F?Jp-cI=fw><8)PaOQax+rf}IrWC= z!<_Xq7K6*Y-%WW3taj(Kj9!O`1$cFFu{Le)hE6&RfvYGcD{vmyT8(Z|M*A zIJEDQedul9=3N;btvJd1jz5f!a@Qp|?zZ(9ZQbF}%!;x2)=P%^x@C8|Wp$M8cFR8Jmd&SZ zpIdgDTSjiWOAoqbH@anU%JOd6Lbt4$G8Znty3#F6Q0BtrR~I{F6{jdW>wNpmakt*G z_||C9Eqm21OHvkf%f9cHwNh5^mU;Y-{9w_9TjueM4Vt3Vy%5)h%nI41Q|Lmb+!`lpS!(-tU%mQ0C&$FXy^tYbZPF*1O0p>!j?s zQ})KMp{Zl=XIHkwCRS5%(xJ(|49}3+l}t?8p_YQ&uu)rb~oQLo?Tm= zFHU_!v$5gL=h@iLc#iR0?S32OIp#ixd9HDutpd+=?(-R*=ey4*d0yZ?kMbOMpP%R1 z=-%*8GH}V{DpF4T>)rAs&u#8=Gtcerb0g0k?z7~eHSTjY&z_1Kpik_J)2feZU|5G_=eemJ-_5XC<(?3c! zIDD4M&mE0FR3@f#;z=>Kj=xz|RB~F=i+Le`AB_t%}vDLBBh#yR>us z+QB4wc`VM8mJhnNyk(h{)F-bKpA#2*@!*~B4&6$bv3tq(n&TNfuF1>@K1`b#>Gbfx z!}RCrr5Cj6NvD$ThF!tLV|q4LtY)E_>cS6`hn zp61^-9@#OCe1UFh6L)1}uM~U)8|kR-{1ZA~LdJFUH~BfvnPy-h8A)doCdUA}SGnG$ z^+{ku5nhzWq5jHr>wh24RX*q7-0KTnoZAY{d1nC^yq`7AnHTc7Gad`WP{4_Q$6k;m zzwHYncjK=fB-h!>&;s4{hi^}t?)#G;m3z-$4e#b_PIgef7{mwt%a4@*)0>~Mi?ICDL!IQ;ZifeH5`txiT3wf_{Kk(J-; zQQxNR_q}CVTv7Tl%YUD{-i}#=bn>wt6M!X26B{)uq3B%4#`$ zzC-KOe!I#`YlL0De2p%5)`<0?O=9<0FP^n#&U*diVt2g`miAfsnK8PocmJ;F&(JH} zYjwYq3&*30_IQ)Q%i;ij=bUMz-f_L?W4GdB?a}vfSFIJfMzOAgIw$sr^{jJ0>H6%& zcge0ST|GW#S<3Oh^J$AU{Qhmq!LKtc`S&D-0?oaYHzoKk#{Ylk>jb|#<=>NSBDQy3 zqQRb#9JGJ7B6_XGT5=bYXyC}+Utl}37U((e|3#0NOBUL4Rxz$Ef9(sdjuCg5@(DiY z+;1}SXR<5LDwi#Ohi$@*1s#5EvZ?rxpUk-lW=1v6bCqLJEYVFK^Cl8MC zPj%vXgE@Xhn+#8SM!b)6Pp$ia&Op9*ht^cgRNvT`|=_&z>ncI{d6W1L** z+Osn5*;_ZhEf?Mov)K>gNu2jlr*Y&kxIf47S#)GpvoGrPF1wgKHoQv>aYxObP(i+_ z;-_9cw@=ySJo)Z|@`IO4STs#?ggMJYwm?QR@!ZO*?&kbc4uP2DP0nRDEacp9A$e)R zn-2VI+pvkB673)PIykI5I+O#71*Pu9y-e=?H=3XL341M^{vy7Q+;ae}cg{6+hL&NS zzHHY0oO`ZY9cOQ79djSz@6U`c&~c4Lad5Qf;>N#XPXT8c=fW7aUiJsPtGhdTGg8kCU`R*q9BpKPCXZbV<_jy-s zWC86F{f}&!v|f2Xc;6=aCfxVVZj#ms<%w&HcNWLX%ROC3a+&Z({LSEvoA)(7Z1Vi& zByX9sLgi_*Mt4B(N1gp=bvFUCrWUKY_kJfIrhGz@)=xgQdW+5oe?FMuUAjL4zrzRq zDd>bbpDb>2ZHVYfKgn`0PeHU;^n&@EZuUqddm zxZ93<{`|kLY~M`Yq}!m|j_nzkoS4hpyGt-Bmj%8walWcOV?XrnNxB|qtP%OGr{VA5 zfahBgi0?nYJ8AtNH~!gLfDRTFtX3BPe!t?Um_tl3OI@{+Gb+|@%*Y2m;d0XY{&%$& zT8DD^7}@uKy6am1=KGa=dHEBPd&9k7$#;;w(JegL?bqJKUswJ++;Jwn77f&%Q5|xQ zC|AfvWTZjisp^{hQTC8e`g-`%UEuKt|D=a+=j&VdyA7+5!Hld}c`><FTOs?g2S!?h)AIYh=znc98p6Lf7LTLyq>9{+`sjjyC6BBbsTlk+6?G5T`HN_)nh#JD)KHgiSJy=l<+>wgIuvJamp#+6F`$sH|O>tq=W)*wfP zC7arl?$}DIuU6aN==q~3G(R`CLiswLvuBii)x!(J-W^*>(Unv4!=6m@PRTUdqlO28 zhx0SULP6I=J2nW0oyzHTJvqHpPCeyv;hPNa^xKmOqAN^=5qB7QYlFNq3eLzkDTo|G zjKTTQDR+6H=2>*3dG7r%*7sW^3l*+AQ-@p}Pg*~Ck1L18Gq-}fwV`FYX8`<;B5Nll z&up|Z*2vydyBSlf^7xA4fn(sJVCd}~ZDiiawyOuW$^U#s3NrajIgJH|I#pVho*D^8nhG`^8LE9{Z`dAFTh zYspi)xmSYtnKq5l8sFYgr*UpfFc$s)Navzs`>ZhEZlJwR+UXqOf9~3-_r?H!t5Y53 z@jP>vuaZx5H1p+u&9yrm*130BxVWkly+31k$$t-eOs zj~e6nBlu)fCmTRW1mtT)-kMK!3>&tV6?KrHv9|xooY`K4!@O+OL)#4!n$7p z{5F1s!d*vp{;_n^I^p{T?>DmkIV=1xEIH@m@Av*(-!ZQ0)x)t5jO_ifcx!hmw!+}x z_#@$ZaFe@su%CzryS6U}4wNI45gWCrK#r+NGU!}qPihYu9xT6yi7{v3FS2{QFu{kv zTPeGS)-Q3`N;a|9O>g4E|MKJ2>n8JI<}Dk+3*@&V=j_l;z@j(LW^@*N=_9;I732V^8GV8#*yh zciRb0j5R#E#IiK*bmo+3e@5fV)VQ(F{IZ6P6Y|Bm4el9Ufcbz&|HAomv5;ea(8W44 zr>`2kuQK-=TgS#(!}9!0$EU`iXk9$NCbK>h{^kdud)9ULK~vULw#F0i=|IH`*moTr z#pEaW-fYcpv^IR)(7HJlFX)^V8e?>N?K9T8IX|c3G4@#;8beISkM>Dk%~$^DVdW_` z@z2OY?6Ya)rJnlWUgFTVOdK0I%ra}Ic|OzRUYs_Ze#lzb!d=bA)+t%Df7)|)D|Zhp zcl=DS4_jUAUC*aSb60=6*HyMbo2oK3m96Rvm>W5$+<&UHhg+N+aR%1ppVnSLZ>W;vg_uQp(Js<9J4jqY4$$wpZ1mQ|O^Zl27_Fv1z{2 z;WP$~u{7@sz+z>w|K}RN#+9!<(do_MEyll_eV7n_8U3MCw&>zk(AQjUIqLfp@Zzec~M{V~Z68zw>iF(x;67}?jp-APeecEB0uL6f-$YWMwllWr#8^P`;x$(mM{5smvRs6!4Kd`_@;axvsQ=X2*sf$t^CMD9m_Vn{fAbtx1T-v zvK2IT!HJyZMpnxEUygY+EMNI@y~Zd#-`E?W8Fp>!pm;WZ&K(8aYhWGyqG^ZR)N^CZ zuhJK_Yc3vCzlu{ruiBOU0{4{#0zKJ#gI&^z@=c-B@d0$w>pP>V+MA-hZwFQzfK`{i zqh5#VtFBi^bMxS-zLVBJU$kvjz}%Swzp2j7W!?#A{c_9E$8NWRnOTmHl=!f|&pd6J zdwcS=FUNEyv16{)C7(&`7hR*Zfjo1p2WD?zTj-EHD13mwMva}9wigbY{dC6UNU*;9 zh-|>3%PNO=-0X5yYl5mm4QPs z$W%M`ETd%xjisoa1Qxfc~nH#v<~2bbarDe z*|sZipKFhd`piMWMRQhJ`lmAo!Sh%?5*SW>UHk775jVGQjfYeA zisjCE+9&i&9=|4I&#+Q=Bpamr)6RzUW!N^F96OBL-$uLoVzu4s@+RE}8Zo*WzoH=q zFK11w7R)_(8CcB3J5mF()?WmMJkQoGFSHGylhQ4xzo(`(&^kxcjjm zUfTO&u!DB$nyrt2ywl>2IKRamaqvEid*b}yQw4i1biP}3R=&+i>zUW=&MWRfhupw9 z#G33a2Ti}8AUG=Z|01pn>}c3emk>PH+cj$nOJgiapkEK z-~ZZH&RV*`uT9Y8V7^6p)V_B+d)W0m@*mVW414D+^k5A%pp(Aa>AS<;PQRaAj?Vv` zo3@E=f)g(9F*Ix8($|pdoLs*=A2jQnIG20z6=ZM5mdAcZ|HB%q!Oc$24W8x<B?t&urnl}DaZJ>+phL(M7~Yl7`!n}jO8EyG5emtgUTb2T@iTLg9B}L1B*@Z{l5q^ z*KTy|P3ekfdo*A5&D=xu^XJ!s(=9{(40~{+*S6PJSs%A+A8hjn2HrI1+Oj# zDThhiKk=UD5=@{|1}4C!Illk(YQZKwo%u7?3&94sEK6G7ecFuCT@S6z#2BCdcJ>RQ znC{IHtW)HA0KbDN&ao8_Ngo?c+rYqsjr#FmGl2`=y%pK;v7t|@eyik$}C&_}y zedrY#*@h%P>;6sTq`3G}d@nFZCQMpS?I}C+NHXpV*jm1G$J8?q=vDh$oMq%QvnHKo zoa3C+*Gs>A)5Wu5TRZtxY^$*m969lV>?G|556v0MtIwPDGy2YV7MGu)uqF?C_!{5; z%0T+6Bcd(nMc3F%zX61HI2!P8{ql#KFE)76&VN z&x?coLg-NDUisu4en0#uU*d~X<6xh`X7q*7bF}YE*WT1H`J5(y2Wyup>89j1nu<%p zp{L|C<(|{J_%whF->N&o)0x*I&e^Q5#>J~;=%30}Cj1Jzx^M(J?jp$q=*i^Ja^h8h zH|77!$^V4@ta0%Fk6rsR_EhIyd+H4n+c=T8I_2iAw*KMQig^S-Hv(%XZ?%>Gc80TH z!+&))!+wd6!4np{d8?_beO=01t#jjT@M_L6`Ofe$c(aqYn*QH1Z}npM($u`weDC-_ z6!V$c#!hxgj$dHhDchL#>yuOb&&*zxZx;3y;efYaIo~k8w22{;7s1@Ysy5_f0PQrf z`s}^a+Iyw-yHH%`+~P^?KV-_FcMd9@%(Lm}{KUiw|E8%2{nW>qfNW^~mj1vpojE1; z_&emggYPWhmRle}_o_ee0FlP{(k+BZfw@JsbiMMj@4E`bV!O*YC#bA8P@Fl~J z<;5BLYuFEsS?&;OU+(xFNjKrFC}PjTmkHmZ>{{2}KrVi4kE1Pr=iimSoqI-^zmdJx zhBl^`&LwsqyqFW(kb3uusLqyF&BG6eJ417K!Y_zb#6N3P^TKCn6S2hRP5|LyY8`i$ zEuoFOPoX2-Gzf2~vuB-ZGv^B2A>q!|+=;?it5cu+VN~`QwV~MZ)Vk%^syK(1&kN^y z;LpB>%lRcJ-u}hd?VJB{KetoIqKBe(;^M=pMZlE7dOQJo;(pKbq@&e$s3fjQ?nl~)Q^ z!oa1@UYT%UvT`A?w}Pf$lhdYAwC|8v1J}n{yiEHT8`)e_&a=_$c&~RWiywYk-?P5W z8efj*DLIqErkwLK<{E+C2i^b8{Su;;24|=65)&Jb?O%M#<54S%Hy`$FbgauR{MFa$ zP9^Q<%=wD#3xoKO^`o<{g;$Ux4LCL0vp-_|f!k-`>#(9&%zTJ=VBX0dth_7u8#I8Y z1@P^pdlnKC-mR*1{BBj>_`1$BzPD%9pP_5)JDrV4hQt?bzvdy{Xy!82mJ1Iywp?Ty z@j{)sdvZ-C5IFA24n6WELihe0dsO*=x~@wzANi+9X6R?{alT`0q0rO#li#hApH0$w z?n>ZVkGwJUuG9eZIFh+FaNNWq@N43h4NgA!UG%Yqyc z*7f^-U|A^o0tsSrz*=}TQ>=|n&+5s@0Pz2T+JA!;NY8h0C1jk z_JW_32X7OD@91s=;9OOc(`J><1)4g+k0)!Df8|_u4Qs#0?5)!cA3;JrVb-UQ*b(qeYY~6qJG&fwefo21gYnjIw)`fXW&dsmW}DOw>${P*FXVsO zn6Kf~QF&G=T%z_)S>zLkgMTiNOO9vd5}?B` z*Hxzv|4{RbXl~GgM#fj=Jez#H#vjw*yku(N_9ob(w-_9T_o{8P&s{%269XZ6*olG2 z!E3j#EPiB%eE!OKE|VdLjp#0Ujgr=(uP}z_=C{j-bVf7t70=-1>So5)`__1#21HeppN64Jb2v+P^t^D(qwr42+oDB> zo^O*63VZBTaB-R7W+U%+`{B2Hoqq7y<@!pf$jn_~JU{ zPhZHhStr@&(C^@*KJt9WlhzZ9wdVy3lZW^)aW$$7e4IFl|Ka8*L?3Li;zmCcPrCDB zL+^|Zx5vR&zC#l}`;OMt*5KIIE=!K#46S_lSS>j-z zS+rC%mi|k0k#ThXyJ@VIY|CK-zYvY3-LPnleQQTs%D$y1y#=1b8I|_ib=N_Q``{<& zEJm+7T(;+)V9z0ACauRmCm1<^XZ{{mz4`F|i9SL0#-E2`59%}ARMnB}tLuZb~M!{rapZJDdd@6`% z+p}4F_DLH4%-YA=pHbNgVgf&m4v#zt%=NwCp1xBuiB+vSdY7to_Ym(r-pwAu?&R$u zUl-p=*N?QH`2BsEak7uzsxR-olLOxDu?KT6oB9TiJ$=rTyX>v-&oRl>KYLFG`tRai zeI@`-vk#fCViLBCKNvqo^7e?gCauAjqzCI;^yKZ5;e?NB*Ur>NR~DDvBR&BRH{0XL zFuepfH%m$@i+kfS&A%Q#GKUTDG?<1qOc7{?1dJ9YTwo96^~hc*^EHE+g+ zeqJ!~If=vP2Q*ITDRVpDY-BZ_HC_`Jcli7+%1@bC9`q_hmj+b#w{_mL?4Z~Ij_X_V z4fUYMmQ()QWZ832?Z`&ca`+8pxakM1LNY{%q)yez74N`WVWB_KL)yJ&(lMOo+69$fQX12jzhwO@fN1A&>`G2Dwcx&Gd$tCz^ei*--bCN}xUM60z4;ym- z`Ldi@kKC^L5fgQ;WV;pI%kl;2yoPb zr(3q8P0X`SevZNeXuybDzNWMni19J_SQE2a?y;h-{N9W$GS0Wv_SP|T_vy;whn6e% zH)S!Wt$+Qn+g8MU-^cfT#QbCXQr_8&^y3TJ^04E{_H1lT$ljh!&-i(65uJMK+b;ih z>`v5KSv>QIY=`C&kTX{_?&2ett_t4c_T4#E=`$g zm(%}mvN1leLwKw`4nFp&|Ll^0Ij1u=#!6#jY){{rVBQwGiPeQ2(X}fk(Qi789wlBV zTl61cR~+^Dg~l$s{>tLNDaVNREV}!O=&E;P>*Wjw+LF_}46MuM^pvkSMqKMeK2hag zIQBlr=IF+|r)HTr_kmP=rCASjsH$r@Z)4q!O-yoAeE*T74o&=jM(DeMET??`l5M$9 zS9&yO=r39g=`Tebnpy#@9xp%hdGa~;`#brDJnhnZ8om4|^JyzQrT$5`{!P@cLJ#vN z@I9Y6BRNuV-!J6-M)GD8i=33LT5*$Z4jybbtbfwl`~95sHewWw|25}M=FYw@_%VJy zNvnUAx7Vbf==&!HH}+i8`bJ0M@#2AnF~PoAt$M-(1829+f5}Ybt}M?hAf7bI=RmO? zviaO&{7^IY|9)Rj@A|;#k!M2%>9Wwys%ySz`D8s#VYa@Y^2=eiA>iqcXIzX4QMa?`Fo0E(<8*VT%EM` zf0)qKdgV?L?J&L{d%u}47N>pIeg7Wldxh#qH(?(nO`es$;+S$cn7sN=a95&Y!tXt! zb!b)0!)Fp1#Z(zz2KINe;vDk+Zyqh&X!c2cbK<%)f@f0#1YQl@`)@|piK&0hKfm;w zqk7KQelyQHeP#4Nvk&AiaQ*iTU3uaUiSw5IjXkaPFg7^oj%bbIy>$l7S(hi%oy_2e zZs^BhYZSV{0gB|f``#eN!1wN6cqDdDWQFH|r_MJbtCxcNlJTgQ<~&!pll~ZZ)#Q&R zt$m9{HxfgZt#VU`ciPKIt1oNb$={>T&=quG))+i6GKqdYnZ)EYKj`HyM=p8z2Kuje z_Ry%OFJX^n47%fTDgK*0Q>PJKI;e9}lNY3qd!#x|d9^7|ICF&_od&lTczfVU!K;kl z*vMDPr#y6j@v#@P#W91|_ZLqImh!RIoua~X!BqGSOuLWth6-CA2sMMdRl0AKv4ndA z!RqWCoXy+~O#0+^VQn)uVPb^2U$e%$pEErh-?&U-a{}wnKhUW%H7t<~{s&S$6~BBA7V@wCg3SIalXGCxvvtt zw=>VW?7~p2-NN1|TV8c=Q1)hgyRNpYLxcKWdY6eu?JGW~wwu1e|9i|>dR7ncO$|JI zl(@2+kT2XbXwF>pKfao!GwG`Q5_fHH3N`B4K3w z5q9IN1~i_`O~`V{P{^#K^7~>R`i?yGXn4^uwCnPlqnb;4G&or7=PY!{+Lv8OUJB-R z`k-w&tVQL_dJ<1M*z#g6}6 zcdb6}%|-aX=m(r3Z8<8slrT1|KF$+nJln&X8GUD=1+AF@W3$M6!G2`!Rk@#GW0_$E zSwC}UmCgsf*f!vAXw=9z_|E@mSmy`OMB*~Jhmm$zN3*WN8y8phCH~I8Eq_@sGIEc1 z=dp9YdZORoJ#t6IM%EKwRxi@&Ci%kUS@Xnwvz<__hvdeF^p;cMM?nG*w&81ku~(tdREhTrq&z1+tu zzc?f3AND_MM>HS0?c}XTCyMWX zbXy#K+mT`R8~ulRk<2a5+Oy}*3umD<^U*V35Ki^p8>~qW{WO}d{l)@whx6={gUO-_j@@a#j}|WKsCU~6D|dnT%g9jZw8<5Kj~_mQR_-Aq^M>_}<}I9(oFQ9m8k-q- z6fLc*yEnbHWv#de(f_x~iJ`UC8Jdk;mih!fL&$K6A^allHv28o{2^%H-meWXuL$3n z`+y~j5XYS9hKMrH4ftX{oT}&C)xvfXF2Su8y8`*vfSY5>s#aTh|JMf0{hIyeZsxwl z(`bL2$_!lWd?3{4!nB(>o;v#NVT}aO?(|(T!L!SZX}#ddcMd$Oy|F3JmHD1rMB|Ti z)boA3d@lLguMJ4|TD6XSN8JKB8uY)$k*{~&k;5=om>c*kV>zw63Jsq=R2(xpn=97} zeuABRj7z=`o{qpi(f)uZM7FuQ0rc9$yCR#AtNS04P56Z|wmRkJl|3ZB_3#GCEy$gF z@S%|HrO(ve9NaFMADn3v-sxLpb$rUunemgscHz)D&W4lLU*Aug(9+x;(hpci)2H_h zXOFU5g?IJ`w?p%--Fz#)wQaV;w+y}`kI3G-d#!m_t#`KN(64Bj(z^~}%xm+OlFu%1st_bei zaeeSX(IH~(;T_*R#5>t*L;Qbm^hcr7#{!`jj$IKtdu)BEaICi?$bH*YqYqTn9DAT* z*XXkq`;J{7I?4Z0p8NRbQ11Frr^XatdjEo*4+QPZGlF~nE9iH1^cfOA)xH8=kHxKJ zSMFXL9N@Vxo+y5Y_tSO`1rOxbRy5*QYO{_}`7iU$TgxI__CLtlIkL!|`wtj+426#8 z{rd-mpX`h9_<)rge>m{j%w}hOg*Ul56)#A>q)#9HR~;Lw*fct)Vgr3HxDI$^ZXKCl zhELo>TaHh;57Q?)*I&&O-gxyF#uzK>c+Zl+xV{x03AY%3kl(G~N864i!EL-R@b_DT zCuR1f(%zBI`1x6P82uXih9@6rZrR%VBG5D64t`q({9Psn?~vd4e#JA>M%gE;z#;aD zAAkM8^X?vD4R+tk*n;SRzNStC|E)WDFP?Gl=D@jo`vbq`?>GDvR~FxXKR95{iHWJd zVdDATN0Qcdav%JavEd;@M4HpA_4+5~qYK@tw!mj>A>)_HUkkVfRmQJHyKl&jO29oX4lv1aE`MJIDP&ihmRo#yY%&ds4Pe?k5tyrV2YS>V)8c-zh;vTxpV5%+JO zO<##_i!F<>tkpP@)}B>y;z+P@nfv?r{t$l&+HB-6&R;WsN&Zx}Y-RDUo{oPNTE(|3 zi|7V{W%lK<$oPWyS8vbtO|A+a@Fb?J##3udKJ0{jDV{)wIYaiIH{+#jM z@w79?ufDc(^R(yqqwQ(5G3@|NBY&6{>>mrkH_=qa+u8gt$SyMy zZ6jYA7)#-oue?oqFIpnm-<4l#3f8pO#|O|+w|9w7RE=l4a`5>c>EyCe*|S1}>^1pZ z>7JwKQY)+5I0rH@(JlRfNOp0sEt^8FWsU8=o1^y6Vr}r2;8pGhVdFufZ!cB2LyFt`Cj42bQJ zA2@+PCno5qp+p;C@?#*8{21~Bg3e?nfL&1RM#a0R2@RC&;zB8HaTgV6w6q&8^!1{5 zu^TFDqh-Grcj?}=Ww*4QFyHt4ob#FaWC$7E*S)XT{bPN-aPm1npYxpOdCqg5^PK0f z-cUa9Jqi7E5oXIUZ8K1fhM*s799nGDxw>i;4*k}r()^_k;_$5WX(JBN*QvkOIHaDn zh;OTF96C%m{4?Ni7&yFX92{=LIsiWt-X$HJ62aj^9+$?*;>hmJ07z zh(inRk~n}vi&Nr#92`oUR0M~X45eqm2mX24|9m5Vv`ft6xa52)UzBvN8{8Km#-#Q9 z8(cG?6AaV0?0Q}ZzMy$ws{@zgaAvU?IB~-c1fK-*g707QCB37K2D!JgI$XYIZ~AN8$|s8t*^3{fnPaat1ObHii)7 zjM_iLUs429KN@-r-`T;bH@RcW z>N5q%Zunor{~+)_&Ls3*0nA6HFXK09#+l0k8+i9l=y^|KFR)43CfJ_56F?nf=|6Ok zpF#hH+=KWKcLsC=84Eu=oG}EGKqK2zVP}T#3jW4g$a%Pg{B#Ki_QIq|=oUOXJ1hC* z9>m7vUL$5b_F*rEv$HciPcZBh#(FHz%y4#wb=k|aGtgNv&m*=hPAbr6)LY>z;oPQU zQ$xqg1#TV`d+8}?h4f4hK?HrzOYUeG) zP&?vHu;7jm{Ou}}$`xFRSJ2*JuH9IBFCjexd~Jd6xwJEpwvAYBm>b$^chR;=8#eeM zOZvj^g`edK?r)XtxlV}0=?=g&#lrH+XNCUs{e9%&MCDuh@=VHR)vrh!EP&1^?|AI^ z0_vm=7EDT0-!E|d89WalOpHeyLX2PEH26P9W3GAew>;~{Jd>V2|=yE6GP)J+Mhtnr%`$o@AXN$U&az8a655BEkN5hqo%f`Im0T zxV^ZCi2H&fGX}m24WBFg5zj$|Q{TVN9$U^btjbx2Fb)GpXCeCrHOvY2qleF_JB{7_ zz=?M>c(vP?Fl5N}g_hc`JHely47q|AtS-jx_c&g=ul-I$%SU;bEUtJ&8&b^?AZLS=DHFOX0a2m#Rl6nqpPr#Mb*`&Tv37rk=Bkfnf z`9ZTkz1Ao3o{iSo-T;l_-X7t@ors=O)tndjH|`ceZM$)xE!uAEatxKw$5;mOVNu3r z^h>>p^#Dr>V##*{pE9=PXaj688C+MNGUBLYQMWnu^lOzUlR@}L-F4j@gVZ@;PaACz z^MFTN;5nPrfob<1!g>K(a`~QveQSH-Uj(c#w6=Yk>De@Q8qp zk&(nZDZpRSVc4ht(2ZZTWeXm|`I!%8X%Fv7()REjAHd&+F$$F39dgdFvlzDa>+CIE z>Md333&wf@KfCjY!zX=OgS!D+-&onSZ54FX%@_meYB%&#*yo|X?eM7;w3 zhPCCN!q=)EXOv&ZTtPpC->Hjuhfki(UyS&@+lj~GL#OJ{-U%_Hb=zz?_cM0ZVXWDs z(3eKHV_v6mUbRkydltyMjP{h?I|F*}D$wB)Nr!dVYaaB^gx=c+y%+1erbF6$)!yL+ z&Vk4j7I+dDc-AZ}OKi@p+y_J-@^{^597 z+ICK@;{E~ko|k3Q4fqtjBJFs1{^%?hR>z>5k2@ty=V9V@}ApS7rNP< zHIxjT0^ib~^y_xu^I9M3Br^@?{xvv$}a<$Zas zgU0+*FW@>zxz2UaK7c-9^W|Mg`Z3^6kdtvMKr1fTBxb_4&X}QPEJwS#+C#ta1*Y?F z`S4JBi|I1HGwz^6M-yGsg_CC!ykkzCN7j2G3v&~`lrvR`qVGl9Mq4h`{`22v zInZWpd4Fmi;ymy^zSSwVe<0JV0OJ7KLV41oQ#^m1>5^Bfuq_}>%k!h{{jg=q_ZlF_ zWsC~&;7h=1s)QYB;HUGf8v`?J+A%OgKcr3qc;}A;SD}WBcrwE!@#our-=?BH>YNwn z8s))jNjBblJN?Pa4f%ai&)gR*5@kHQCcbD_@;lU?h2^djy#vnL)%-9Q>L5j=NBV#9lU#; zOy|A~XQ$+8(lua+_#p8fAoZKl@U!x6L;e7GY`3_y4R>t2R%&0vQQT*q!hIKXo#!2f zui=rgcbK)WA>z05E;IP`V%MMHoH0S&UFKaY_-GDseFM!4bzVV!`upXSt%ze%K-=Qr zjBgy2zH;zAT3{ou`hNv-kg%+^=9f(5L_W+k~4iOSz7{g5lq+ z?gejM20BXPTQ|Pa+d3A^5LU=r`glj}bg}1_l#jrR*~b-ct+X5M5=M>#`|w`0;~Gz< zM)u$ET_)~%ZnsIo!W~4smwQ@mtf=%Zu?o z{7F-pH&q$yNu&>&(qGc)gGfK)6dmv3_bh(jwu9z?r(1$kCtZ%+&jwfGtqkZip!rlu zt3l57pL?+Pts{+%P2cifa4KvM4kf#o-@P(vU$;MLKgy*sek8`G_#frazlr|?ivOot z%fJH}QMdz&|EDHpAl+t4e@~4EZ^ZkpCjae#G5!lk51Gmv;}0QS#*rlKSl2dbymTY| zim7~+PQQY5?Po8`m+17XfG68jey)Zm8|m{+>38V#`AE+-rCW4*F4FDM^v+Lpx*h4Y zru3ic^jf4hn9|?Y=?zHtn$q{^bnnD5zdAQvAM>lzGk(mk&SkV=88N?tQ*jSm(E#Rh z()?iWB&-FUC6r4;+z-N*fi*+Z0 zbX`6R=_WeyPuA(#NH@`g@7FpV^k6m7kMF!r2mM%0bmDtYr-M$c1yT5YZ|d{{q?^`V z-%C2(iFAjl{3f05K)Re4g$G}iPKSJf&szjPz7mz5l!UyfM4jj%|B7N^8GW`DC6x`)~$%v#rz4#jj2f$X#bd|uX28f4of}Fq4YG4A&9q7ypwJ69SyEA<&H@U6@B2H zo>h?b+vCdW?j&5;mt>(F&NZDb!%q!+k3sk?gqTkJ=kJ9*Q?7L#FG@a`23++@{8RwG5eeUJ zYlyI8FIrESRopkd7hPx#8TYMa%rlM&`#Rj+y2O4+Gsd_f2TP!%o8(l-9kNdg?h09e zBe(XKgKSs&z{cM*jr>Jgjqpf}k3)nmpo^MyNYI78b7hlf7}B@F@Y{#~xxN35{Ynp1 z@(=xVa~+ z9pm@!1Nrj)7d;<@(t8CNq?!xQ(?$EO@=Gz$G%5o7l`~uj<)thD~)V&_! z$=?6^h${1J70Mk$?1ePmA%pyq{u?;Qs^xnKlJ9yg_Iw*@#v<)P`9mW4^e3BBn3ms% zapR6iK)=mf8eX`BzQaQcCEX=6rX1VhewOxj`rCt#&Y~?R-dD(60XxE$*OLn9H%r@l zmk;M<;-(Y+`)*CEyGtZY{~CDg>GNruaW64&AT>wsKi>geCjO9mzu+De{DwK$@OI!Y zFX2v2xB_i=2P;K3;p!>?{r%4rd8-Sp)qUA+TZ>Z-!s0jw818#VUDpAQ%7zZ;7Sz?5koGw(`p+&+5} z{r~p?4&V5=THlYnLE19{Kl^P*=igm&ef5vHvkJP&s}coyUCv(2^jZd-#T;y7|2h&zF4wf(&y@`G<4n4=6`C*S?zctK~I+a?Pw8oOmzX_u=&L zAZ?f*7KP8|_X+V~Rd|T&EbkLho)~ZON*SZt&4oWX&$*=ziQh8(<2_>Nb1h5YbLW8U zH}plO%|%)<){e7!y^}UQu6a(e_5-QQoDf@0>mhBCI$rBqsXu|YYEAWB$hYYFuj=}2 zU#+LRtq$ZT==^q_pJ~c3Hsvp8KInDpSew&&zh0YYb2915>peQ1HY%5FTdtq$m+5pD z#%|J~*FPxJrzxD|1HYod|Ocn?QRZ+HlJGMB8i^ zx?p`&cd^>S?n|yb%u~Jteg_L-|67H-*c%vkLZ7>x!2S>YuJD8Rs0X19Ut!vz&cFXY z)|AFx=xUkw;~W;g1N$R>n^Qyr?oIZ9_jgi{bMz)|g+F;M#z$Wht2`$U@xhAFqPtMW4OWnRZ(_kk~#-25yN2UdbR9c@*!#gdgv)u-LC!s;UrPGTu2;6a& zc-bAkNS~O6!|-7N%$O7XMy170T!jblCfx9)?$h`A2Z%q;mvM&;=T=sZXT>p|cVEOg z;vjY45y0T`@5TKNfj1a>FdseQ0`bFn<+|vbaq$r3LTZ8I2P1a3#8Zml;{d$6VZW|D z)g|0`gSti5KQ4OkwpOM=52OX&RdR}TFB13ckL?o%w*T_S!u<-~-_vc(Q+=s>tC$n? zrTUHZwFiCSE|7%(7|*|xIgU);ogzL^CnNk#nU+fbLY+qXJxhHgupRnB&$UZz+rU>> zCt`HobOY9rHdW{Rd(;_B81$@P4>|QQ4s}ecdd`AF?lPn?ro8B)h*JXQNXp zvWR1zC37z2+ut_}oL{(%bnvx6te@-3XWpPZWSGEPC_~+Z5r5+xeF!+SIUGA~DUh+(jYnx$vrA=F}pWS$S>2FDAMY|JS zxPPJE^+?q3dMv)-yB<#H|3?de55|NgO}0S>5^kK)^H<(E!kUA4n6Mwp_LV&g@geVE zUE)%=k!orqHMR|`i+1iIO2Z5K^;(pszOTx&3iOdqn;X;Y{eN-EF74jUd*Ej}B=7q6 zCX`b?Jn5<;qsl9ABDVx3|{_TimR&p!fDWxC1i}la%g?zjj zWu_+0m+#b<$e19wujzITC14F>A1kdHEaQJu)z|0F>P{!h80Q*j*9n{&cgG64rsAzJ z_|$eeMXKNTR9aV-uyVi3`&_;RS56n&mG`+;#@y!u9*Aq-UAN@$JfW+QaoXrV0e!pI z!Z@wiUkg`PVbXlYZQ}VL{TYZ?%-t2hags1I{^5!rBkt5q%%6{Qz5>X~I>a=2@X&QI z-z@LD{ik6DjM4XRzJi#1h!yNx%U}4Xz#h$Y4Dz;^=l1@;t~@01&Dfet4SeH%EO4pE zkPG;)tk|yRQH>jSxG`SF@idJ!ndQ})Nd<5-I-uz9?MBRldK2e3VslD6=$cc+>8`0s ze+ypql2383v6 z8h)_K=o9^CN*M0~Jg;LNb4yzXV?_%1B~srRYm>owR+rvK8hc1%FJd1y??kOTz64-1H71@Id35C8^FKR zVUgB{G>oU{d8EB39J1U1#{3%OU!S;l#qr@uz(tB3_aZt43=oFSKk=Gug{`!@XEj(@j;|9cWLxYn)sIpQIF(mb%@JnT6i%}6W! z1@bt5U$d6UxD?R6q`ccLYx*HRPiQHL8tzD5Nn|5K;2APm*>jB zXW;K)=bmv6@ekbRhvt)4EYc5wwmpoI_9O@CX@NyJQKlXDo@qyNQl3QYNJX%7pgrtU zigD*n1V3dv?(Mog2k#dLz78D1$3(vOejNG(`=_1mP&@Rpwa3wKI^Z(J^06cbmt($x z&u;ui#(X{8(}C|YIWJL|oq*W^n863D-_tNlxoLvgsbO|RVP5@#v{Au#F!+S-8^6@) zu?|(7dKYgCVqX@*{m{_#n-PcL$^OB+l0x!r-5ya9d|cIm9JF-fZ|XCs=Nj!3)6VY^ zb(^Ql_&K@owRd$ET=P1`SNj2H0e$Oy9=v&%`9cTz5O9MJ*Vg;i-zDSVP#+EKJ}h8& zfvxA7mGN+zY(d)oy`&N7e{JZ;dung;mCVW zxbi;6o}0QH>dClt@4+_t*9STR$v^DqJoWvK&VP9qYftDg6?@jwhc(ubZ!_+pi!_c6 z-{SNq4f`k~;44JiP=U{p{#el-OC@NgjW$T)hqk986$?Np{c*k2A5|;>5AXkhCc&4m zf0L(Hd`LZUQ*R|+1ntz)PtxAsGNi{1zm3|D(QglQkxaSAO^C$)z?&UnE6Xv~1^8?n-2CxD z;>2D9Uwz0S@Q)Ahm&vvV%)GmDD(MU{k?3=byW#NhB8`G>x!!YcNW21$w2SAGwE|B=K=K8$27OC?+QqoB*Lu{v2jD+E=1m9b zGZlH$0cT90E9x?sGuk{#!+Yl%@#R1RmAI>V89c)KM3|#0#5YJB!97UoJyv_QO!Fh{ zGSUW-CREz$Q@Y$4q*-*@TcC5?-?W~^8R*sEM^+iPPR4&`yr^r|v!&sif34SCyrnuO z?priAK+GEoTtA`X4pTmG4fW}GZ}ywQVd#+whMp_$rNIA;^hO)4p~w0DzkKL%n;QTp z_@U~jT>HSg#|U@nwcjl<&C7nyi}X3hI8EUr|tzj$#*2VCfNIfc0&h2*+Tl(Ayy{Wh-Acb!JQZQ zJYr7poxy%0es;%k4{OzJkSF1t(DztAQ_4g34c&zCq$H0b4{O_xv~Qi^*8 zyb`CBh2!CndrB=6$Jt-V_v@w4Hss?ta#5~Bl!x~IK$+sXRVx+GB{&0{ZLo`ogZM=Z z4#>r8zx`2^{}Qq!|ACH(SIK{nyP%!1@7`qG;N6?a;6Lz#PsjVGg-#o9Qbj6{F- z&EQFsoGcB$`fbv)mgQ}!x7A$umNTt-uz})aXz2}TpmxC)I1IU7tHI}wOq}w=bsqkP)p?>TXk3V_pc+!P%7w$Vj zKOgPGy)gU@TQmIDpH3wmz;0K-IFzG($=!nqxbN{z%ms8brMpyb8|}NwJI*1wUpkKa z^who7o*@yux}9T0J3UgTgI)<8Lcv8Hw!dx%;ZpkK*LeS}mO7n`%^a1pd>5%q$?@uK zG6qMlvX$z7641|d)RlHmV~>TjFQBb#+NuZxWjo8nrbX}${F>!1Wd(Gmh<}CjkJ7r7 zmcM*=CoQ-Id}c-ay%-yKQqrK56VL8bIDhIvjq}_>Oi=WeV^RV)Fo$LLZObCDLKOMR94 z70aCg9<(m?)%qA+O2*AJ=~8D(!wJUQTxvb!Jecf6h76}ZEcGVsFK)yOr9BY5Fmz*H zc*d^grJ`5O3*ubzjx+Z9!5?C+zX$f*lk?KbY2%#1_>>RdK2)G=a-<`agYO~QCoSWh zMmgV-mOWSH8YuO#iXx>Ktlj~dqd&fUe~Yx|`^emO$=i%+z;+{a7&~6*^<2ke$BT9R zM!ro#t;L%f)Hqid@y`z;mK1COHX|nKuJOlPGE?!|s(s-ujBz*YN3r9TGR2b|-H)w! zOxHPx@n+w6yv|d)+>ww)U_Xs`TgQ_^96!$nih3e8MXA%6_cXM1aZfGvW_@16`ImYP zXo31N_R8g4!x;}N|9$Wz;>#5sv+z!&SaE?ipOuI6A#fqna;2QYID7?Zm}BQ$$gnG+ z=~oeF5OJtDZoq>5uLWa2%e@@du4Emr?j-bVtMt=3Zl3>|5b>>K*;n=auRJ>O{D0+b z!Uh~%8BADt*uaUrbK4^tB;Gj&$m4PP8;bU~{HGGHGh~06Cj8GIOK)E(k#-l1H5`;@ zoW>Z{eieP;J{I+}OyUW@8RR9U4~9pW2K|h_FS(>w>Sj`By@3s%a|N5B7b+1?}WBH`kmPOHw@A51Y@**hmq8$@SdyLyXbLb_bX z@^Ls<~eTO?dnE4d^X!)zw%^PHl1 zdhl7|e90YKAUENgvS|y>UbcKB(j9w5H*o-;57;&;3kD06eK+_|fbSY@WhKAD zhihx_L%bu4cT9Yf-bqt$N?4T*cmVQXb7cWx%}EE0j`!2@69OIl4%^PU0>SU41^WIb z4K^MTb`N)-PN>XY7!YFN-S~$x3m?M2Z(@wcAS=G7>}sdquY|5N0y+`4!927H`J(W( z_@{(}J_gjKxcBk>cm(h3fCi)XTctYyzxMvBRLl|f^^g6Y{DSs$yv?<4b*jy1~1`Xb?T`5@zhWT z?k~QJc%{L$IiroMr2R_jfWcqpgd2bUZ{gQmv`xx$F8F_B!wxpNsMliadKUBdHH_i( z2xEy@B5~z89_oM`1K_uRzY()3Wz;#J@KxR<IC?aiXESuWE5pzG8AK3LBEL`kYqmv6GD z*i48QA>*pR-$VL0~A`*%5`FRqEs%fKi97H<47C;U3*rRP68ACLBHn)-iiJ{JGv z`uSM=www>(p7UYgo^q7(l=ET8(+JHS*?2HIACJ7v`H(U|ui=mp$-Y0Gm!|ChlK(Qo zi2Z>5g47ep?~;$*Bi)i_dXtWlm-4ah?O1UE_9Szxbey+#>GQ(h`S)IyermqSmk*tKBk2m(n=Hr=wVu7`&I+X@HjM_|uF->a zIinBPWsa_^%VfVH@p$U!Iu~@gOS4BywH(4bzN6nv2K^!rvLj=y;pfj%&IGl5X`^3vQ8)HhkeT*LkS|Kt&Wz0Q_Z#Iool}&ZcXW$m zP@yR!Pg1@F7eT&kMt$JMBwy0~)rd*|0^}gp{6OhHknfWNr++JDi@%z(<*8WN@_UnP zITT72mwL;B868&ggg!^84NO9u{vxfT zX_-ZN1>J*hP1V{DccgY(Xwxfwl|0h*EN};!#a;JQfAwYf=;#>!u-73?#_cCPM`$xb z&k4cNb&57m|BkkkG4v_d+QAv1&li$8C(y4eT!7g|8fAOx-n_vZ3G+ku33<0xjlbYE z(yOFZ&@5=Rf;9VolveSc#u!??3+v$t%3i%5zPR>~qE)PiKlyD=NSt+rpT~UnShjtB zdVP4-|C{u>@G%ozn&@@m0#o{Dpx2U;&q1%{CVH*Z^jbk4H{`sgR~b*h{+$lDqF3iX zOTGckqOWB6H)T8II{64O(ZY`2KWv3Bp~+`^@prlAp}yH?Fx4p*zoyg6Fqh;(r&{|* zy5Vc@1srW5$58i&RoCm(_Wq82gwN2Uv4>oSeQXl;hU!cpp)xH@xpn+=wK^nWBsztOxY%6cI?=tZA0p#o66Y+;HlSjvnMF) z(`5@;);=A+a@hCboV+7)PL6#aeKYAN6wfzP?)R}Dao8WyVhiw^w>(J$NH(qLe4;Drgl9HxG8f^fTl@P$3*5sfD_73FNGaqy32-zf!%lp?_pK|DZqXY7`SdP7aomQl7Amh%7ooY+U>n1*wexOPoBl!w(>7dT8O_b(KL%Fza=(J zILdFGv~Yn zpS;UP8^xB*jKMj{CF9g~f{s8tfy$@Shy%xo#4GU2yRzanbx(r#X?-)!K%aYXlhXgn zilyBie(WfhzM=%S%gJf*VS&u_A!+t^D4Ly{c3HYV`tE*6?uL#<{bZT!|8DsEbkB?ZV$ytaknM~Z! z_Av;5N!$y_3-7t9tZnUn)_c)cW{bVu5|DF0Cadi5VvNF_RTyJsu)3S1T zPNc_P8czCA_y?lp{+GdTCzMXj{J|NlQ-Jqxzw}e|>Dt_de|r#rrki|e$)Il`^j^pt z(e~NK|3J+6=YQ_;hb(IR_rHX@4}j-ozylu@_?;xSfSxJ=)91s>`zE}c0$z-B0N|!H zZ2fll1nyjO&3|=Fm+(;2Z#TFcYvT1!!Dy?1D{^%Helsl3EH0n!6ESQA9sSU zdm!^}!rhK^jtgT*4IGuSKAAEGGWjg+7(vL>cOZKsYpuTbAlF*R;Mltll-0-ggm)OS zn)imK-L(&PS;%%NyG`pZ@1aTiE$p(|eK{Qr}&@*m}bC3uf%-V%}!1n$!b#@V1y9&El7rdOEk1-f^ zfr}fiU4b6#dTGn-k^H3eDA{&twpsVXxCRgA> z0)5sC?tcYsoDk=DmMd*@eHhb#5b9oFVG`FV;OPkFAYIZ4e$nPWw3)tw?~kEh+Fc;G z@9@8cy=>a$L$*ZhP2G2-)%o>V({9nme(Y}9SFY@93FHKAfswunUQ>RQfY;O)bpgPs z;;<4;hk|@(w=fl4$g$mNI!@w?8TGo20M#iq20~y|NB3@+AxJ;X8%3SeAPd zX7J!w%>o<&YQYE2`7&Ti#CUfE;$JbKE)0 zD2Ju4F+g2o>HdjyjqskjJlK4JL#(Ht;axY-Luz3Fy2ZaP-H$rbCUg3erHAFbV6Nob zYu83sa;+@-8zJo?%p07+^7C&2{u-q&^$l^+q*u7cA4_)E=NU`LQkOSm!QSC7pu-MN z`VH`}^n}kduG6M*y^nE$&Wy2@UJE@J(GxJg#D!Y(R2}MEgOisY4*!DjIW11ekskQl zP(PqQ@HXE6CGYwkynKjl20pQ9;pw7JThcag95x_!SrNY2B=*FSw=DyoGmQ$OT?q^>nJ;iZD zJq3MgJ*6D9K)?P3wC!5q*0L$hD#z!0P@a2bImN8+vTedF^_+=dhQ33X!#yL^?HeE~ zlpeDi^^ZqsKVQSom~_C`V{%;3!KlY@TsnP$o~NVZ=_c~b2)1$Z75R|7-JcKIK>O*ALw|HG5K3+>NBkSgEnkT%=Q?>M7C~M?U)t6U8{}g-j2D8~ z2W8NUMuN0IK*vFUD$a$W6X6~V-_;vWC;Gwk@CEKssq0V&f;=_ux&$fLB5?@^u&%)W zfNL?z6yTp7`F} zKi@4($G8JMHsDNT^L_8qa8^I!!tl+i2H@7lJxXaf*sIej=&#E1MLmeU13#j`UHF@C zg$E^V*&RpaTkdJTtwYj>yY$-WsnK>?X6bb`Rn~n&x3e;4kA-=GELVFhw5wpab2;?s z%coW*g}5Ic9G!%C^AA^?D#SU0+XcR~!;j3mb2RA8V)@aVT{&(?AT+wno`bh)c8+E{ zbLs@XalSx$7tllaEcPQ0;{ zavm{!&#y`f4PBdL^}R20AWz?ubUiic;;FrbC*|1-&QZXFDMQneE@I5d=T9VE94t(_ zKzKMWrQuuuy~}SshWnsLwLM?n14LQ+`==DT1L3N5;c!7SBP9#aGmm*aO;?{s6q<05wdqEcecD#gG-1Kkb+QoiR&bQZ@QyTuDitVyZ z*mg`lMNVl`Abi*_{Ys8$M&U`cSIKtZ$CAN1^8O9)oPm$1D~|Kdralh_E|gDCO2{VP zg-Z_E5R-=fOR|rdvj~^+?f>Ez0B;9;P|ity2Muy=W!e744#1wsx5oh&W0MN_&s-Q( zu;of0yUp;;L>grc`;=#2C$x{Ate1J5`4XOEDt55y_aASM#;;6p6!9ErC3u17%sr{p zgXnLp;do?g6pnd6LD@6ZF-gDDC$9(i>=oyLuOo<6X+C?-+BP*}x69ys_^V;7gZ$yz z<@brRsFNIc;g=nN<@fS@=wWp}&$UdZ{Zdn2u2VE9^2SH6k zHrnX?OP;{HbH$grmN~_}{~X9WO<(6qQ{ITqJEilaEl$!%|B8LlG0y!I>u0u>3Ht-J z!|E;u;wY6~`}@Zf|5{Q$lON$-pTpny4T(ovpnk$T8R`xIrh@{n4ClBAr; zhb+rqRwh+Vd#? z4f0a|ip$YC%Y6`Y<_5jM_iotmz3U$1qXk=9)ZcJ=zqDEJ7Rvui(Qu~ZJMf(S-NoA! z-`)RDlJ61<&wy6P`rM6ePw{6$;W_Fn5uZEYk8-gHellFo^crzg#%LICT%6PX-v z-MNxF>Ltk_JlD?EoAM3+9hQ6l#`?zxaTIka;{bXD> zFHX}qu>V1fAM%Kr7rte&>&El4h(2t3{mK3SbsI1*S5~|L+uY46MuU{mxVz8!()2i@ z=<%jMXnMS2#G&z($~gK~-#Y%%4zFk$w3@)Opwkgeqa)F^NrbR2sWT+3OC~v>Y#&k% zJhI;e=Nx;V)QOMAtVOw|wFv79Y>6_S#Dr_oA8xQF4aTlX!G5KiI}mGWoHgl++GpDy zqx=LOGfZpJRh{>sS+*h;c|Ye>%GDmO3x7BZeW*>!)m||OefMmzH>pC#dGAcBfWDiI z{mpvn!AMtc4|F14lYDz%)|0w?1I{8Elx{q0iB9t(4L*_BFp61oWg5;FWV^lAblvV9 z=sQ=-uKBo6bqVhk=Njves(V+vt}EZv3ieuaRo$$ABHW<4Waw^uHxY2Ew+Ug#Fzy!N zjCf`{@9-qi~Earv0sSnFR*VgVj!IOIDF1H6T|yRo4BVi?jOd6r2ZSb5)X2=NVmm*2tr!9~G@qqHvvUgKJma8TV1o;_Wy^$9)qr(+J@flcTx zH3zs;zirFAi9?79WXt(eQU>3c)pE{M%nW%4-`@W~2I!Ue z?m`*d9mkyUJ#Fk8c@C40Gnl+#=(OqKt86>)4t!OIEH=kxobleJ?kzYB{Z*bD7u1pd zm2Np}j#_8u?m*jh@YSVX%jeWz=k6F+e`Q|-{uvW;;R zJFmUlfpuR5PhcF>4Okc7rPu!Ty};|k&|{HK|55l8gg?HT2VHImbt|R4BU<)VzQsnr za9=w1@~@8wS+<97*;sNJo3N_@u?oISf5dmve3OsnYm>7QyFwK!LO+z|-ThX5hCNao1R{T6Qk8Pm8Y>ox@s?+(-k?$#|d?&7} z5_WRfB{_$IH!E^{Gs+L~EhfIp?i98K!AhJ_avW1nBBs{S9F9Z!&G&{0r?z9wrEd^? z&yGfX&mdn@<(fQe?oOlJ;EcIF;g4_n4ZgFPcluK~*ETr^$HODgc~kNSxUau` zuX({khR;&+JK&Y^cnCh^yCOW)10EXhOc{G{xnBn_lBd8=t}Qi51&%K82Kh(ID!q8&G%-nwm!t}*5=%NKtY?z+VNQ>|S0 zChPv`vA5P zzUh^c*DB#k&U*`fDAR_sPLJY#iAca1-&NY}QWzf%^|BcE4fY*dXd&M>yQ@AleMH|u zk>!%}Qn5!#$3MRLxN8vj9YqZM$e!F}E11_nnAG0j9=x@Hz0Uy8dqj$)-S>~?=zYAY z&Vo#qXFaF5=S3+yXXLn1r;K$N`>D&HltFsu`6lm3V$Ddv9BX?*j(c2rtZB|E(#{9| zJ77M6SRy;+uk@cCOvtGVTVNCT@Q1{6uH$W-ak<4!=+_7TmPGtL1?k>(kQKSG^7^VR zskRz18TplgZrM&|;1%LR+0jvcl5CT92FxAO=d(Yg^E@q!W$`zCJu>cp6*3ri9eua$ zy&Y+ZMSHOSaU<@`ba7bP2_b7DG6-^p_Ca}einCC&kIV6o!#xwpA>Us_-r06Q{#@An zOBL&*Xm?^CV~04!jFoB)PwejUW9@u_@-Pu=V`7l!bBs#@+U8q>+0tfIjkV;-+d5XX z(YGUVUp3L@0Mc+@6}U0!ojH;7Jg1oc7Tb^R@e)%5FAOO@K|hXTX1mV(9!W#e_C8(e z|EJ%dHG;aN)t#V;4Bz}T#P7x1YM_sJz8Azd>dj|a-yI6(vGg-*oPcb*3||P z&&^tdv%2_J#ki0k4UOqeac`VM3>N~H*oBeQ3ijp(7B8)rDEE5=$kvxyHTKM5u%B5V!9@gH6^E=oU7_(-9 zg?=sR9_$Ag56D6N?DQw-13oGEw$rz_YdY)`;IC+Wo%D9v^h0;!F35451&B+ThEFYE zyewtdSa_o{`Fr;_D0uIFN%8)y5x_lmuQx`<-!hr)!H1zG1_zmJCn6WWd%x2u?k>DR zn=vvs^(_N-+I!)Xf!LhVE|DwibMC>{pgEg8!;pi}oicvd0s2buWhBB5aIGS+YnXB- z7w0Gz%3k~pnXKr}jWPM|Kumt{0mhe#G6|@g&2M!cTLGC6qF$QLHJN4jo9~uq5L+P| z20Clrkb3^x;CsfAls<3coE@BaFFXVrte}oB@2A2i5j4kG%wEa?(4h2_*zzst_Pe3m ze+zraE_t4BQTvst`g}W~hxo*r{h-$Mq2p;AF=94Cuh@!r522Ht&B2;u!<*dTNs*g3 z40~hVt!bSen97^iGQ^~$a7GPAGD40U&dL%y9HLBpP0^7 zAZKpL!5v}5w@#v7V$uAb0w4Pn>;)|OphfN%?OPY8$a6c`{+#00B)qXGw!EkIN|=XK zwP#8FRX5TX*f4j{ZRzjZ`M=)n2n@om1RijTlt%LRu0+UY*xA^IQ{1r$Z%1bO?qtl3 zNx$*kiTAPKV;Oiu@3)owQtKIgHT!e7M&(z=aYcVKNz>cVP6p3}X^)oj3%L8t@{4%B zb3FMq^Xjh%`5JX%yjvO?oP2LGY;p4pKE?X)WjW$$aK^oYaq&y9 zU3-!9>3ix{__pbJgfDSGU>>Kbc<4CG&X&IWm`B$2m5k)DuAIZY6*+4B_hN7JPv52P zz(lFHe@RnFo%QJ3zru?p(t`+UIaNa>L|LqiDP2_nTv!<12k_s~$Zyja5NGITAHX)Y6JvLH9U>KaFMQ#w=Qw|muh@54mA(Ch zkoH*eCUD|KThm#ue9=wwVRzYyy2+?JDC2x!FEghH^}ito&~7sS_Ld}wqP>XIH7)Th z*K>@0KgUI!49=Kw74vxz^S2*oSy_-j&*?GaEIl%3hp~Phk^GK*J>)a}a4*uQ3vgzc z(*e&#dnez9y6rg25C;BYOq_2gd;y0zzZl06;=}jj#Gfhrr1Sl}ERKON8+Fir8s!?> zgq;cP-R6ORho&0`Ws^ZSS21Rl{)s956US9aPw30ukHtgI#h-pm{P7Hx=ca&-cY@}_ zKhO$1Wpn%z#zh%hQKumI3C^-mA38&duD^${vK-G>?I_3cJUd1CZF1gKKbxX`7o5~} zJ*_hl?iE5uYr%pXdmJpKcwRxPre6d9*BDk{ICq@B{_r`RYM8t3>j@+k@fGO zUAqo=O6W20-OLAz}^7;7-8w=?}dNY^#%;upijjh=))IK@x1d5^rK~<1AID2-GSersa)zy0mhBnx+s}C zCHz}IU>}mEJa2%n4$IhW@Gmcr^tX!mhVBZy6aU1$od28Ar$GF7%sF8lOaL8$x5zg> zymPDQNX2s|t_{4$;=HR9?LSo^{b>RTPv*d{`GTBd#IvWp3I2bisVt1+iqv1WgO=~$ z-2yjxHr4+&;vJC&d+}@BCy;ueb*jRpsNlQ?-pEpWrZ>Qk#yuO-NB_MSNFPdHx^1$e z0omULzLB8qDI8m}I)h1q?H%#}ZANsM=Z0vL4nr48hOczbSo{4K7{8BezS(|{`TRn! zP6t1HrkKx;;57IlW9{%xPGCGLt|O**#*{w}#)5c6|6BU^L}kryKLxyJB|q%8W`R!i z+aw9+C5|X-qWRg;{8ahA2j&vvw`LRG{63s}LpBfx_*=>^@*edm)I)kQ-zTx`nwIpp zMj70}lKv7>KZ||ur%J^F7N-AbYvumMUzhM#h3i01xZm^K3-&fYVlu*4Ti)>*C%+<2 zenFgkTbz8v2Art>FJFq2e>er=q5XPo@(IQgj)=g+?q zCx0kT{;@dueR1-)#>uaXlV27mKQ~T(+Qj(}T#b`|Ax{24ocw)p^0&pwZ-|rcijzM- zPJa5t`SU_?@`vN(pNx~gKTiIRIQiZ<`Q>r)?Q!xm;^d2o^XFcSlRp?I|6rW_?l}2v zaq=tTGIQfU;Js;{2SEIQi$|qbzC%-#R zep{UUia7ZNaq?|(@~so+&$<*R|4f|x!*TL=#>wx9lV2Gp-w`K2GfsZ;#Q9m5 zlYb;m{;oLrzBu{rIQhkK^0VUPrx^Lt)MfeRd|~+}+%>=H!oLcpEzX5KO=gb$U*U(o zU!4EPRa1>SvT^~onQLoUo#fZS$O!zzw3MJ zS1;=F?<~9}=jKcI{_Itq{*8xb%W~NdxvH1_&tJb8T6j^_*X4E=uK&x|y5{`LEeoHQ z?K^e;uXTUU!v4{~$D3+jT{xin84Kn0UmVZ>jsI?hr-w$y_GWzlAST_YADbWhZM0_8 zH}d198~L&2jr7=Gqny!?k#D3so-|TE+pkg2XfO6Vww3==`LXT9_8;4?@om&IzKwdu zw=rLiq?W_BlW+W$QQk;5zK!z6x6zJKE|UMl2jqXT(zjO`{Acj1!JiR%VDPuWuSzaN`1HM;twFZAbk@Qr z7xeA;m)QP|be8!n{~7g--`MdQ>9K9arvKmu{CJ~!MtS2mwp{GDQSKq#kMV1iGvt{e z9~XVux#1ErjdHR47CTQyxgQwq5381Mly3BE{6^}<;32lYQ9fR}F%L$&vGol2jdG4O zRl;Fazp?dZwhGbeXp_7fwQD`dXWPxyPkUNj}uY>zaz*{WYJNv-m02) zRYXQflNxw^lNb1}t!k^Xd0Uz{)Yp1y1rg(EYHnX!XKVB{Hn(iDRc)xMZ{QHcvgTS( zgRQQr)z*Yk)gDiit=ZdF-&p?)D&oIKUF9Xqipp%Qm|ynDv?rD?nloOyYOB5#Jrmis zl1G*@5Q~?5WyvE;9xp0iVr#8$YnNCdjLTa+ zEpu8t>)Syuo?06UH`X`l-16v$t+w4`YiqV)#2yf?0jC59RI~|0@yHLhx#-?SwicAC zZ}MOo>Klk5bDGf!)0cWcfk3d01q|fb)&OqKhi%OS*sl~rwk%OKPy&qf<^yqIEz7W}^j+^bj$pidDutlQjBJ8@lG*38;j zWPgG2d=|7w{I%4rmQpJZvpgR1h~tLljn&OJMxSh_-8*3s!t}(WPf&c^xFM8j@~j2H zQnKAhxaxUFLzHij3T>MvD*Tn@i^LL5Fw2|PH8pQ+5|0}46K#FP)8uIZQ9Zt-sEoKX zzL%A_B7c`WQXctxQOP5sw5iJ53Lyk$$5m?FQ!~DqiT|GPv`HaFPUhb=%^N%<*d>pF zM;^yT4#Bo(rg1@kU~F?R9_DX(S#MC z4Wgpn)2a!qzR4!b8LIImK5w;H+jdO9YWdnF&ZM$2+WXKn2*P3TUwaHEdc z4{;HXuA^m^d%d2PY6?4BV>=e?YL9JUp$)vFQ>V!G;_(vO(`96Xw((n3$pDh&Wf3g3 z)}}7!rBpt@=i9 zgQpP;L%9Xt}FXQw6d*T30-#1wrks~ z8sbSimbcnl@pBh#Q`daI&|5gk_ctJQsWF2C!W>RapDy;P=*KG$G2 znpQV8L(?KkRXLfaTh?jSZp^lY2_f%$Edi=?h2_hMLBjsC&w&1=?R+I7C9 zjm9c&*Hjx#^~{og%RGq<^^H|VD(*&pO;r<6>1mVewyp#H7UMJUqfkNE)QA<52s07R zbUnfdLS!20^>ODDMn7uYwax948dW{dnl%_I)PqeXST|rR33WQshK82ks%MqJ@A}p! zJZ&YaE?}<3UIeQhHmv9rLt4FPscQ^OM{8}*>aw10->MSy}J6Xf1^^%{t~MNk=# zMz)yAO)v8>Pd6003R$bYt)BMU=9=bKYCsUEAW=54vA(U&ri#?sqGiyq(J$5>VCwpQ zDOb?1Z{EjupW+b8c=2h97;J-^fxT9xh-qCTf>1V^ zr9fV*_D-LxO|uF$woPJ2ws?JeYL{H!fR)v@w#qwpgs=ugM|geR#mZ7(i&%i7Yl2dn z$3S6jjC4FkUobI{TFHdKVnkg6MX7$}*@~ctGo(}9W$TZQSa_4$| z{l!Y-)^$zACs6Jc4Aj|gtZa@c6Vr#Z$W72bae$3zbWe^Cr7%f515_TYuiS{^zerh> zdEh?Uk*Z1JknS)Z!E}R3hLR6ddDenE!E`hZ%)vN;p7!SUR&pxk(xXdPd*^yOfYvzS4=IIMuJ&WWrC0l$>OAh&o6`NGh5GTJvp>E(MQf+m=;z*c=ey%u+&+ z^A35f_l?E0E2>WxX$7(y>VZ(~P00>btu>yeTJi(ikg5Yn0qU8O(+1zE2F9!(2HTPE zz+9^vym>axCRQcb7GO@M8La_!;0DNOZLB0eZi2{?mN+R7IkG0`k*!L8ao$%;MUPsf zvq|<6x3tJ|zrs%cqhWj2WoiMs(+T5*e-fqxy2FTf1^F5 zElY8VBsSKEUZm}Zk6&*;)O3X^arL9??GxrR6{#o2BTr!ilIEb#`|xjO>!UR3L(m$g zHDh75Rjr9CQ&QMu+h#6^u#qi`i}K8zxoc+5oTYg9x|VL-l&nxw=c!p|5>vOdS){5)&lc)+HK1W+s)vzQ6RkdB#VL>DgrZr=ozGWOh$&z7z(l#Wxfy1c8+STIOj*)V z<7sGswmfk;HShInR^vzx($EkLJVB7G!lAd;HMiqb06ItkKPeC8UWl?viI3Ga4KN~& zyDtGjz&5@breuMA5I99`-oev?i;y%;*r-8DHDBsGQYuLWs~Wrgb*=YfrCRHe;&-At zlo;1lDB;e8t0t@fRBCvBMl(w`jXp$ejpgUD#hrB!5R?Hp{X zYvoakaSGQe&0ZZa#5T0m!vJQqu9{_C*W*0m!+Gm+W%t)@wW51k%sM1Cy*MNE*yhST z5%6$*);!7Y#Fqx25GyMYPzPLc{o*<=n`=Wksrzw{H6|6cA*$GzZi|A8rDSoV-|PA? zb-=o`3mD5Mco?b>S9;?}MbizbggP$_XYwGIIt_rNW(N@=R>e_e>rmhKAoAR^1865LCLdAhSYG7|%jOFT zj?HIOdz;bE@xf?&n~$mQMTjuOemBF6NBA~-(au>@xmxvo589XIDs;OTAIH1d#(Mb0 zfcV>WRJGG}5bbX@+Clm*oez60`$1s9G2;tfGQ*F2;K@AxAmERV5BY~<^3h*3AJIg1 zsQ&Oukm}EceABps@H6GNF|ME-&p}Jzh=RKa{c*g3t!kVBpK2%2CM-uI<3jlc^<7|; zuhZo!(T>v?KgyM>@1kvL{sMq!SFtG{@bEihtM1pK+sPJ|VH}YFPt_Ne&SM-ees`*IcLEQ`+D!cg)wcul!+Ghf)#Wh$-6p#3w5jiV zl65)BuNYqn(#_+us_z+ce8S=%Q0@7_7sqm={rb@#za3uHo`0K=bnn;v;>Y|S6Q=TR z_3dydy!b%}@0#HASEz4?gztdG@51*nQ~fga{ZL5P&jp;OdGlwh?|T3S@!-$WaHozP zpC9dWyvF!^LoA1=vXEEgTi+2?&$l1_or(7E>r>wj;EVI>>%q4Pe%~(jZNTsA#ph2PgO7Ji@R7oTe^{61$4{OJn*XWjZYm*Y5Kd6xLtui)?4f6(%5mioRI z*&P_$GZ$64XD*B__YCNj^;Ee7mS+a=t?8TXJabfi-{rky%-zOb}wdDjm34Z7g?+Fj~pNA$Q71rJE_XGrJ*0MD(6i;XlVmp_>Jd(EZ*b;mezr>`K`yy z`NGnw>ArOv((9t_w36=eo#WQ+RL10E9MOEVQ?B4?bwCmdqF1KK{=Z)2e|j@ z^+A>c-29#gJhEJimUk^XRQVRbXXsrrzk=x~XV>|;z>lU^=C8k~(${mII-=uRPki7z z$E*5Te@vGhFsRt_QB@?_mXp6Zq%+dO04`{CmgDFY=Ef-!!k@!|Gej zE85WV*juLX;4Oxn(R3%_DNx^~TUCF}`%&Me@X&Dbprv`A`kuQ(SQ<_qur%+&x5ksq z$GG@Cw@2rr-0lifeatJr=c1gfk9ir>KInnps(oQ;b}BfVQ)9|u&dueTz_(mqn$CiYq}C(8-8hrhS#-v<3#tbe6kL4LCOUI$No zmS3mk@w!3%jeU?z_bI%rlkFU^tg984{sz^*yX~N5U8VXi1|HmPXh+Nabxx#fdXwcG z>bn^DVY#RExSz(jzmpMd?`e#i-;W?&mP;WV2P{tmjJ+45;D;i+EY^MIu; zgmOdC_UbTRelG^zSg%gwxvow1Ux)qmbJi>d3V1Q|;Hvb`Dr-&w^iS zP2~pFckzfWcTBf;1nF*5xr6GvSmUD>{gZ!cf$u|CP2~U>*>S6WmJgWMwhCCoYR0AIaBhhhJ1JC?+`*gW-T`oJO-^`ePZK~g@ zi_v{M`>nd5zQ2t5B0p52{l7UA?XRjweLq~G`m5?z_^6Wo3QLt!f2XKlH|T`(;6A5+ z2iPyZ`&9p{hXI$SpB3H%meuHgcdqJhh4-Lk^*NQlbU$A5<@XttzjT1#DDT2|mZ^N1 z`d$jWt?&xVYQV$(R_ChzRuTWUX!%uF)c4ZEs=Za0@g0HZ;Q!Cw`^QyUm-+wi+rjZT zgCjF@Mo}@b$T=!1Iyi%gib{1Z}*_j%pdb;Hg1|NGx(9& zgTukQiFFaI`JH!@-Is6bF4B=}i;nA6_UTQHoR8*fP`r_^t|*S|pJ+a(_1{>~csGu3 zjdvq;OZ+h2jr1v6|Bb9)G~SKDdgZ(u`-n{Co zv%a;-`bGNNHoeuaZNdfnyiMj2>06u3BQno6_TiQ|L(w=nudT6&w?2pK*jB4`-LPnO z)NDp<&bxtrOx11flN;!V;8b4s)eQ;NU!O8-_-*To-)8r-xA~iobFzQm#ysS4@0x0j z^R{-)_qJx|joR~&K$le9v~D`CC#mbLvi@aS*LCB*_f}bda8sM}u7i84ule6PVm7D` zzZkk$#IHngQ;YcJytl}@xJ~{o%u{evlg53E-ACUtur9 zX)TIF9a7&$J>=aIhkk6v$$2gFTlp5NKdiSUuk&wVKgs@U=`w5AWlO5azdafseY4it z(!lvh-&*Pwhjq5p7R9NF#>shaE~@j*MRmT}>U^`+`R26N`Q{d}_;Z~-ytcV6Z!T5b z#Qv7`esfIqZwmHr&U;g4b05k6c+-I5H%+Mix*m;t9rJ&pS>wKO#rLjbJp{jxKD==S zZJp_uPx$=!jVn3ty6Vm66M=Ouw(O!>F; zSRD4J@L`Gl-^=ssw^NtoYp&FOywUpc#$o1Vj}MpozV}A@BlsiK zd%2H~_2Z3QoVR@&=%hd3kFUExPq>k@QM|2g6KT@u7 z-mr#Wev^O0s^T_u66XyCjq`?i{Ot9rgTG>i|P21ojH?Udr47Om&n3Fm!#G}Qavwd0Ea ziup>OYln1R*ABXk_kV)(DLdc6`rGrv;5^r#?Eh=&d-!}%&Nofy`KGbW=YO(3O|{Iw zu$jN9Tya~y*4GpV&qw$Y#ckDE-!<0vYls_-a}7BKYaIT{N0a8irjhwghVgRVHN^k+ zScrY^nli;bX_DdwcFaCtI}KNbya6{UODfo6gbkKt6CL@{kf`6<6gzQqW!t5G#bbElI%m-H$Ck# zZ!q;qpL*~M@Q}{$9n3Sp8J*Y76NU$MJ~uPpfFIC#yuV3s&P&QXB6TKvqjkdfY(75@ z{JRu?jP(lqsViE)yx$aE-(*7PnXI7h)^I(Y_j+5O*Dq0@JxyY!Un(uWjTkCjTqn&TqTE}aH z=L0$Kwb`w8yf#7Jm9Spldu^3sdEO*-zP5C0ov$s~T4$s6qmgwC-=C0vH_j`5N3h<` zYYgU-^BRY?#%pBVH|LEX>ni=0_wj=`{W|ZzV!Z;~r}Mpe$}sCL{l1xg27Hgs@BOT| z)Zf@m{K!6OY*VcJ8NPM%@h9+aQv5OE1pdjQdK;qkI`2w*es?8(jqax_M~ZZ5UC%4~ z%%;rR{q4#+UN0|fuEUj;ivOxc>L5><>7Ce|cf~yX;HLhHX~iF2(z>r0BmZKAA6Crs z-C$l<41ptkxkAr*v-NDK zE6U3{ZsyH-mra4QI=@R-eebeK#W#&R@6uK0T{fZlE*s+fNJK||!8g&XKsRW*{>{3A zc)g0>6%!r#I`A8c#A#Q26Y~t>v`HNDR$II()}=k7uTcDvPSsy(eY;fpX8Z8c65qR& zc!J+fUoI`-u)bXy>06+)zP)SBbiwm+#&-X@w4QwRmS5u5D*kKwDseAaVDYH;lAur6 z;CUW4=m)k}=W|KB>guUi^!0Whtf$WK{i=H2@2DSEd@JYcyE&>%&pwmaDHl`c!?wRK zW}jWWs`#C0{-P0*i|zh@ah|^0brR^N6sMSPpvzi3{Ib*_U(J%ntD#R1H*4MJ zqAFMYAV#8w_r9{cl}FY!k^b}=c~l#yz?qI>y$X>t|@=+j9ISR zqj=x_+-B8%C@%SO-nmkLaN3TjLU#5d2k}LJHv1*8!TlrWo!x+LO#RMW_Pw*~6c0>0 z?@ZS2tWnjUm5{tS@2o0#?i>7r_r0?!6c1!nf98bNcV^(1^Y*VX-#XQw(dK*mR}{dFSmP*1GnS|KWy6o&m-3d?(1$S`>$M+RQ_o28$!}Z;ZsL zQG7T1@r*Wf><8)Je!IT-++%>x0L#94^}5+5vvX=+wJJ8}y{etO35|bR%J*K?qWHEc z=be_yd9NJb%D+8O8;F0oa2y4895kj~@u ze)T(D>WsucUHS(OkEyM+{a%?j zY}aLF#&ECM4zo>WtId|GJ#E?Sj9I&GP7C%6Jwh+*c$(>7F{!#&^qH+wd+LJOL9^5; z_s5E5=25BrKPB#a73?#?x0gEal(_RMEMG;?PjFKGPnlK!Qzo|hpCaoV@ju1#of6cO z^G@kuAC_$9JEcqUXIC`eDJ>EoT@yd2T#D!#6@PYCbtf-s{*&j)SFXB~%YEq*%U8)0)4b)*_sXTu;5%Z@E2p+{TaR+fU*4&4Pn?r^Iq$?Ft>?rH`O_Nb#9H4w zaZvH+TF}&T44A&xY`ap-dVevErV*&=%4 z$~v6TTcqnL(zRLqCbP9>E7a~=Gi&qR$NZ$8eKTe!%?9)3yzSe4DLWsm3+L+$SDKBf zjjx!UH#=o^%xu=|h}l82J!ad@TAp~)aD!RP8&4Q6)4uLqQM@!tZ%?z~I{k!K4 zkL$d451Z|>^A>M+yJ3sF+v4ty>v{g%U{G%vais3D5sg#EK9YS{mXz~3udJTF*!6n+ zobQ#fhXp^%^?m#tx(f9_e$DKd`X6s~9p7T-Yc<~S3FnQ^==HIy#rKY{Qv7%9(_JmZ zEHfQp9(J3$U8{=k@>REMMf2?HFIn z(_isdz3-LQDt~XM`BxO_OQXE=cG^1bT+;dNv~}D$Xt>vGhgrMscLwW0j%7W+W6tcP z*=DghZwKo$T+n)BeZIG&QgMcU#roj6KW^dapWu)`c5W+wtn??!4;S%6MZC;ElK#G&O3TW&mTR_`B>z9*3K8zeYEVKjkvydH2s%&WAs(#bu@KL zoUwkv&MUEfP-5#@60B#=D;aYeuZP92B&&FY^$Yx}HGc{5AD;;8LPx&^k1-F?Z42V( zylwNGx7WK8ZyWbh!H+GPj&+ddD<0>E=QW<=diU~*hl%A{;H8gIz9q_|S(Uo5(?LA< zr$PAHAfEffitqlERy?xkz&ZCP>fOS}xAK3a?kN99sgHP}{~t$+_~9acpolNZ|Hpr~K4UgvHm>%_it3K&K6ghJ+1L6wKz!dFSy22P>Xdv(X3cNLY~K92 z?xc<*V`lq}?-ZMJM_TwCQ$sipa8neMhdvAc`7+6qb8AZ*&+FWaWxiXZE_wdt^{6V}<#gFp%@nRW#3Op6zI}|_4d;(tfiQXr)9@!`0 zN3&Ls(|NwQs-M>a2D%s7-}3ufkJM_M7qc6m-%@@=@#FMQ^1Rqb+-z6}Sk`+e#J+n` z<^lgG>mTT4KMh8BnHTy;)5goZ(h*+fh5pe#7w?}xne$YSKZhQlHB*NFL{?TUR>%gf9U#t2@2Zg5}HOfEQs`|r2 zoBQB}Ro@-XDE_CUb1$qqcbL9#e|3kMzwFDy^uu0fz@w)hf;aSyrlYRMTeXfrM;(H{ z+aYm@lPHQ)8I6;3FHBLV`L9m+?uALkUm9_4bpn30h#x89Wu2q`vaa9_f9X?{mp(=L zsv@5HqWtRoR(^G^h!=gc&j0rdzFRF<{N--ve!q}&&#!FdpD#pt=bmRjN#CDmU8V2O zOaIC@<2_G2!Bh1T51rkgo|{npb6MggRsUSvch3zg&T(BmhxWN3e$G9|{V* zEBNcId!Qq}y^fL7x~Nj5O2f3y2zjX zA@Mf+rJvFK6;XfZo?X*ApOrpFbk8nEbvgI!0yt9Vv$BqnJkQP+`OifC$z#{Sv&<*# zoAl#Z>*Ke2WxnWIte&Q#c*&x8^q1#B?pc|C&1V0emHh|)dYQ$;%6|CYg2w${(I+VM~N)&Fil_5VGr@&9{p zvmd{m_uYS|6;Dh%_giBBcf09>`vbUC@ozKg|6BZr%XB`4r0;$^p!o5;bA@Ei{g!yc zl@VU{8~AZz2Yeg2Ji<3CetcGVY6$vAoD$AQ^U!|5ng{KQ)>T-NbpelSeFf$puD8@z zu=#z5b(Z*rnEL(Kve}@I&iz+b{r_vkd4E5r_5Fta{1?}g;2*6!_Z#N$Uun}ZFZ(G@|y?R=kE`X~9GA+FqKo=H$&r`G$c zao;^tsd#q6xnEJ!GbO6~)jH?x{wBI#tty_)sBW=C<1RL8-o?1$|Cm?*|CrtE^Us@{ z`;TBBV>^wv`=I0B&zpSrAJX5+N8C)8;YRKEOtWC;7R>+Or#0WdkD6^)`)`K-ZNPAF zKIi_eb!#2}mQel|YhrWm7b}`4tm7ARTkH6R%!B)NSjR7>)c@zfzN0q!A?xw;Zk_+X z*!=#5`Pt7u-Q1e*{-s{=kI~POdu~$ob3^Js*K4@dECoq@Ka+JR(e?US+IK&bbpZbo z{mhwOu&fu-J`RT?f;`%}9ve>$o0emcHc|4&oC`zhCx z%;zUn&iypSVSWB-gZlr3en|YE5I?Z!#Ll*9zFG1}-v7h-z?Q51F>{c4{y z7T^82Tk(9IVCVjsoTB^ZwynB~zSR4}wApUW^TTrIJ+!8AzB}c+AC@WpCH?&F zRL=b{R>YS?dFOr*?1!BD!6Nn9eP81IK=v8<`BsU8ZbI|@V3^NGrOD@M{2w%LjsJtD zqWIJyeft4*e!XS0&L2>h;O8?I-|4)*zo`1}PdjhS`YiQ)pFRuz{kZ1+{up(n!aCr2 zToJs@H$EHXo%?>UF4%sH&;A;#-mK^QNyWeK)Ox;e`|10Ys-Irtb7k|J`so$Lzc1H( z)AaALo(Ru=5-iUnWgVvHz+DlZ{tA9>%y{Pey|=@AhNp_+O%}!Dy4@0wer$<1O1!~H zyb*AFhj>U9BKe$~9@73#ciDWo-p2Ci`6vCKmi~aBk6C>U_(%FbU9ULo|8!lH zCw{HP$6xlt(@WIbw;BIw=@pCR>*a91PcuKk&#_;mKTp@0zD)K1(6crEKg7T?A5ZK5-XeIT zKRNe3)_*fUSn8wy8+utUnQ!PX>$6e6@4lB&ew*#5?+t)&4E6ARVB+a|62F)0a0Q-! z($DX8!>2<%xC>0bG#~z*s{dt;&i8vsnJ4FEUifXx%X!~Ttw(XrO|eeVxKk2$BM*A| zy6NxSlD$_@=O5U|Eli{(<|!sgU>Gld>M@w|!3Y zJ}Ld**njBT!F>^Z5=_2r4{M*FYycB~o82FttOXB7^wnVUZDSwHx;&Wx6Mx(14OfDR zzirBJh5GaUaj>7CWM9bR_IHPMzTag&_IYMEIh=Ff9YkNH`6h>b_uT>I3-|{(t$ayZ zFmZY<4)e6nKWiM>579WC$`@uVPHJnM$vKTPIm7i=L4N*8zR79Dzwgt0lijA1cpa*H zqBrLzi5L7{r03idz4)>Jg#T^9Fnt&PX#Ag`=E)X|(}b=)5+_*{r&0OeE?FGbCmQF8 zagFnYzwvqdApaAiik~N!)b|AI_|UxO`F4-*o~Tj$OuKX6?m@#om38^fq}ZJM&ItU} zrv5uail0fU{yQntwQznmqH9+COsnXK!+ajfM|kEV_?c#n^X+M=pE3I_utPeZZxi=> zt@wG)O_b)`x9QXO+CuERZxcuGvBVL6qK~)}nkT^ACm$LMvF|3@760d`=)tY3|4$yb z13mGl3Y+mKWF5e<1>rdwwXTWkXkElfC_c7Hb>Cv0WFFrN=9P2b8fP7>@89h9-M3_& zz-t}OeUrWLEqX7HOW*3Go~+gz=u(P*T`M|xsedHGw<-R0wefY}p$ISQ3;uPL=J_V; zDs_F+`uojFc)70m_lEWAyuLR>xz!IWbnM_>auvu>!}G=6TFlzsK6u@39ti?K=OjE&J}VCdGfE z|6g0iuh#s^)P614hj7G^_4#U^`nuHLXWhR#srY}{AO1LeH#imHW&Ys*Wl#8W#57J$ zbgioU(xUHjq65qOo?lwbxty#^l&9`Z-np;LX?oi>l z=cgjNHpTHV)3utene$^2T~cv;#B`0OtLOYkL|3agK4`ic(_k)Mi&hytIx<18w3#Oxwfv%hLg@}%QDR}R^=~AX^=lpy`*Q$7L z-gGUdYvO!9qH9#Vmw5*D(Z?Wf9p}d*x*ElMnP;HmItX-CoXfw-cByW7#dHPEcSdxJiubmeZozbOoNtZjW)$yDnvVVi zd8as^jOZp5@2xZ4xaoY(S4VWCiubbLr7y!=PeHsP&X-4YgNpaYOgCV=|2()g)Z;%5 zj@&;#JEi>or1?)MzrWM`$H4OufA;HCcZkWKRepco{701E&;AMO9|E_Bdh%z$iy_8; zQ2G7rqoDq@^807azYjbd>hWhkPYs0_{~qP{v;PDCF6H;9%|8WBg?juuz}XPv->&?A z);I8PRet}F`8R_j`}MP|zu^7BekC63Kh+b)12=$YLQMR6<@cv7KKozz{gW2I8r%`; z@lSyL5aVB^{Qeg6uTWloFD2-29K3Pe;a>(Gjrf-;zdyJRiC3aLzt0l*Ke!I=3iUbn z;2Jm|V&6R|`xSnFyXJpzS^51F=D!4P4)ypif+P3k2N#sz-(dc8%J1(t{~7Q=#6J(7 z3^DnqmEYfM{*%h@_sxGC+z{%?KL(x(G5)^t`)ka9RQdg5=06M`3HA8PejN)j{u$-> z51Rjg^7}{3zaQKd(aU}X?{6|*_Ge$n6JPe{V2Fv|sr>#fi!b{Xet(}}jz+zoJXouC zh&trHGDM!7)qVef?}o@D_=LD~_Yc6cZ^P%y0d9(7^hw1hIMbJc?Ya*1u_#7gqIh3H z^$*N~ZQi1PU?z%v_Wk4NHv z|GMIRo$7!8oa*n-o6VXH_EpZ^Uypvq>W$-Ht9T#R_x*AB8W((yPagm87rsjIwi?0C zW$2IeJu{>AWLWpF*uKm(_%1W0_=I*e%q3H*`Ds_shx=B|vah5s_mMZSzS&WUpL6%J zeh<}Yo%izd>3dfd$HttyH_d^6pqnnzkzf2abli94`nh+Ux@^A(@qEQ6E?c}7&3|vb z*($TtE%Uu+T;tp`h9CP@`g0HO_ui9LTs|w9qgnm#sW!j3`IVuoQoljo_qivg_$2ZT zGMB+F)eq7)sduoIpYyJ&{_bku4K^!2Iq%%v#J+n*^>=ru{_b{oyN`?hZt(}7JgoY= z=C!W7CRKme1iU>i-o-rbVqStzA@*I&<1U;3r>)PQo};fdTF<9DefQ~E#m7xM_vua! ztknJKN#aeeo0X;PMDBeFN{Kj)3QS+2Swzmv|fg^lytl>$JtcuZZs{;yb|6`q~w5#BVL~ zZz=Lm7Wp?8`E&o+QeR!v-?>keO26ns3G1HR?8BYwieJS#OCRpEdCPSqeY|sOYo0r8 z-WxpoDB6cRhgHA94;A?js(yp#zP!c1r^vs%$iK75KNaJ8GyW2Jbm{dx`Jvs8)PZ ziC{F9x(@wIoVUj@(e*DXK8bju>z~#A-QQ;V@~v_EX$debc`C8_5Gcx!$?HY54vkzPE^%eG>JTeG>I=E#h0Y@_o|3h=1Q& zl&6Met+S6jpIy;9Z=3R6Uzg%j*+;kW^Yy+a@LGiDx)ppX`!L`uz=a6Ux(Ys(eRkUv zd1Bh9kC9LAgCA=#+bA~YKF0ov=Kq+)qaMwV-q!b{t6Oy+U5V;)?xU=Kw2qIm{+o5c zFBI|fQQot*gH4Ehv5k^S*Tz zex`_Le~5mAA1UI8i}*BHu5(Y~5ug1d_!UbQzZX0k;d>OnV!?R!#}@zQB7a%esDI;D z|6Aw4d5a(O-L12VPh*X5WsPs0mcHcNt&`k;?fLPoq8nFyZk6fAOegh6|5*NvS2t3|VD13YB5)2v-bABLCx_hFgGgy#EDi|;;Mrufwz&V8r_J_a6(@Fj|0 z%{+wv(D+vW4~=d0|4??T|A**@#M|(fzGgK(e;>nrNa_KfL0|ZLAMQh?;E@O~^?=VP zQ@(o&JhaJovyTLy!QSeoSKSjb@0{zV&aADU)2Ye=x!)6z^yKh5t*Le}w-_@(AAG`-^zF-ZpstYOJl}UowBG`!89KZ2M-u zzhwS`FYK3m9KrhL++PfE-k!gIu-12fK_0;eR~+9J3NLxm8Ykep6rag{5dMRUTlo*p zMR_!Rx_>^{rFDHUMSQmz?}P1%53;X5Sj%DccS+nn)pd>gu4_T@ndrLcS=X?}>yp0o zn64gOpW?IF-(4IZV7{`SKM>@1?v^FRw@jL4y`^8bIQ+UaPUoWU-oK{!oI&S0xi;QU zUeUdOx=1Jc20zuow}DfUIIW8LE*#>(w}5S3f;`QN&!JC}=Y7kX=Y2B&R*mz%cHi;$ z7Xp0l8k+W;d!O{VIl|8>K9_Y1c-cS62tTU$+=B2NbxfGPysy&oRXFcU^QwRE3i;xS z>(Re=CFkBdh<}6f?`iVgd)YUFYgYNIy-jF(HO_mJMY@I}U6ttYSy26Zn8%lfH{-r% zM)9T15;y1GGqyF}dt_dbyzd#XIP8Nj**=i^-qWl2(rS&9lKIzZoWNdAr*;#8`>eb#p!)rv2ozII~X99%a!cXRz#-OVy@{6gJ3gLuxpGpljmIRu~B zjQh^C;*02G`)tm=vnbv>Ym4HQYMt+}xbK)ZJY_b>#ahEryfW)o)1)V8mgWnaj= z+gYE_mTP@)=XFGTO!39^`|Twh#FgvhCiaLt?%l-x_-vW#+uD40lgtNv$+&ZE?4_GJ zH117JoR39xNyV4=q9aZf*hTmX#g~j~oEwAr=G=`%x*IE_I(Vr+66Z$tm*6l?+q%}@ zwyg7R%WHjYQ|yP#X8yJb#aGv9{z~k`^%itA_6YvGam$JWa804UTvK}||a=xIt>#K;q6#teY5i(U5@D3KZ38xtL|;9s(afk^~|cS zmHYPFW)wFpI@ij5`)$+Ue1vD+1vhXVwX(ved~c%f4^C*l>xO;zCi*ToS>fDu!|<~2 zqI}I({yOPzguia0h?hD?G=6iZ@2*QJzKVV}cjnx64dAf|U$6Ko`V{bz-})W+OMdWG z^~yJ|fg|yoR~3ixo3lmyNR)T(+O)32wVh^Lv@h2t&<$x_P3yk9mUR}~ME{%C@vBrF z553-lgQn~CU6bSkUmHi)%Q32PuLVKu|Kdbl38sA+h{@}MZz}Mv5m0V9-c-eOwymMD9 z={&AjV4j_t=Ze;xyMlRyp98<5)pu9SDStEl4e+e;ADt1*!F;73S4^TyMdC~p#Ti%r zX8In)87qoYV{zCA!RN$1=Pn;5F8d(-ocQIV)KjVa%~QgIE0q6OlVD;8>xy3tUAxv3 z#3?C?}i zR*22H%L>$EKPS9w&UcqBDSlVlxy$A_eAQnzVs^l6uUYn}#J{XWY|dRe!+P6#ToU)) zrPGSrTAaItwUozA(O zjf!vSF}@zm^9XrgFNj~K_?DFMtk>vbgs)b7OPlfZbJSi}1pbwZZ)rBZ9Gs8%#}(hg zbrsZK3Z97Y>^s4?unz;C%0~T7{@}XeTj-DQ2Uo$P5q?GSEtSR>z}8=>@8FW+Tgr`J z01rj{=M~=)7ydDKa1J{U&%c8{nES+`wg{d9%l-}dJh(A}r@?g*JO!5h6zXN4RYtJv zt9S&DgJTiQzBwrC8TxadIk*yH`Y|MR8kYGE8V>r!nCnjNHwSB(XD2$3bEW8HUBS1s z3wG|pCB0u}{VrsEA55xW?Tqg(tWez1>s&3ps9jfGt*ndmf%u}UT~_=7_FbT3 z-f};yrQX1HnWgViU#;v5=?ne`mhdl8EbrkQSjxErdGaKX~pjZmGF z{Hl4g*0)z>40owLeN}AEozDI0i*|jTUgEpc7Zu-5+|!A5`l#uKIA5ys3Uq^tZ;z?& zv|wL5cUp(WKMh~m2d@a`mvgUZW?v@M|I|s}y`oX^t<2-pNqDZm2krU`_!7mp67N)E zoEr2k=T4>G;P0%`U(uaPy@KyZn66*zJ(a!(-y0&j7IfW;@1U=zvWBNtm@dwFyI)r< zqoWSNcZ@k#vCJ{9I-W}C-+?Ax1^2m%QN?#qR|PpMlBRRc9n^>a$Pbud2r__Ivoh$i*{P>S6em2O*eCWfJ-8X`KS#VQie)L87 zu{Nu3Soz1;Z-IV@-;pUq;twjm4;%0U{N7(lgr~QHzvLU=OaHnf{q1qCq&~#d+pYNd zCClHb`WIR6AU^BAZ7!nkP%OXK8St&({*Y(BEnq*y#HWwKKVNO}o0NYZUEtpUZVUDJ z*HceLi1Dve{`nH~uT}o}Y4c|vZ(9%b_*Xf1H2u>3gny;-&ySiv^Ai4ruzzKa52}ZH z{7d=W!;VNlW6D1l)Jr_-5dQDbN&P3U@w;t{p&q=-cU4S>*mozdDF3;%=0AB^`EPZa zKl}3#^OgHw5O0C+sLeH=Fm(iY zQu#aRLy&LGx$Vp+y#7x1d2Z1b@y{xMIG8W-=%etjrVoMt5c_3ge~>@J`_%&x|3T$n z?6v#@%D0u!^N%Z^V%|ajV*JkKLZ~M{>+-(l5R;#M zApGb1)&C^=Cj9kl>VFdV)7PwQ=09nfpH+8l`t$wf0e{wz`7bH|o^tb_=e;DZANeQs zoHWP!bZ^f8q*>)JX)%B1E&O5T8R)0LbD7#v^~L@~LI>r;ozFSa1GGJ_E6_ zU+`~ae^GyU|2wHc`S+&GA3xz=3hS@oJz4gL{0r)-CjMx|KcW1U%sZHWmGUn(nZBIQ zxbQrD!#@sR9q}(yUVc^@_?Iewc+UKByscr=zkHqdp*QZQzAIl-zO$hI<*Ujk)9PQ& z`O8`&{`C3JBmFNYukhy*SMrxHDF0{HfBC%Z4(^}f{jYq6-xXaAhW&@_l6k%X6270&A&u z@s<2-pURLYKl9o#7sdmZJ9pl2q`%Cgq$A|1uT1@4$vOx9DOLZM=u?2{v-qFZsQFG@ zhaV69bMC}7UjJ2u@qKq9eHQ+uHuaa!bqjy`wD~Xb^X>XjkN+ZnM?&sjp6M5qZ$&5h zPvr4l_+!V-e}>=9a1np%KBgh82R(U&PiM`4Qu)IL^C!-ZjrAq}7<{DvC;H02)M@^s z%D-4`{=?3_PS%5evi>Iy@tp#x5R*Tn{Dr~#fCrQxDKmXP>pL3Oi+>-lc`_0IUgZxr zS^jS2ch#FebuA5rdi+y-4{a>OZI$4C-y6zV%R#Kd-ZKY{%!_&KZhgjJ@_d^dRF z3Vtq_f6kr2zB!8iZt#nW<@>uN{s{{_pWg5X6ZfciM9;j1f5G~B!i@6IO`87{>&<@B z`1o^vdr63Wcfy47FW7!MVO;qaeDlwO%R)W=7#)`4@;I{Xbz?`4{jD>K~-O zwNQ`$06f>*hJRZ57l;%1_bdMbbp-xBJU%7E^~S#&KH9G?~H+@890o zFZj1P{zdY)DlgwZ6y$GF{@JkpB=LqrJ^qcn7d9W(!+aZ*Kg{{Szh3!Q^;!NJp3g?> zujcxX&Of1iX;^=i@<+n?mvcXl_Ak!;BI;kJ{E-pMU#k4!(4XntAIZOOo%q}j!v61D zQ@-Ew?^{*=CFUXh-&erahI;T4?^#Z5&VS#c@e7)NA6EFPl=;s(ckyzl$A1RA5Mtl$ z%PW6&#{8$1KfB-jC)gj;k^IbSM{|hrA5;DX)?NC)&sY8k^9t&xFOL+$eB>YI^~qw0 z(GMwq&!G8Jhw!Co^T!^`{t2(2ebhCYium^_zs5X+{JqL&%FMrupILFe$-kf;>fAmM z#v?y{626+c1OE=?57(N$mG|kG?}mR1^P7zLH!ClXlYxJe@-Go5$jANkQklPJxSsgq z5r6Kl!k;^6{^S+@aGU89^q2M9n12=fr6a6|`YV-xA!Gg(%HL6H{`6sJqu=zO^WFUs z|CsV=`W)0>qI^fS`p22q_Rh`x@m1$a8$;~7_=@s}2L1!eAEuAN{QG!)9=U(Td%>BA ze~@xZ8`lf|^yMDbQ~m|@ zCY3KOGfW-A|4rQd*`H_6qW28*eD$1Uh{<20{3*;Mh{y9+;VV{5U&-~k64p!p3a*cu z5aVC2{1N&b_>))oBlG4TbMA?*uwML2oOg=sr=TAEnTPN>;)ws=b>(-kuG0U#E6zKO z{)F}KUFP{}br=slum6SLW&PW`r2Oe~=1(2BM)vPs&X-PY*1vaF`S%9-h)3UrUr(9; z6u%cJ`S};rGwHlD7s7hbPbmMqgAKoX>O&g?jwsd}gF6#N;ni{(R~P z@|P-q{;K(tsJ=hc=iHuk=XTbH_4sbjn)21uCH{Nx6aJ+I_1{zA`NVLj$A5|IoBbO; zf7r9A{EPG@@W)U1m*>oX7QB%U{~2(1#6Pe6%RxT!Pb>e&3iF?!p21L$|2Vij#OTMA z|3jVS_mzKX%KS%&*BR>ZAEsX${lI@n`9H?ZKcoElK|j#5jxCju{`E88$uJ)Neac_S zJc9Z6D*s}K;??thO+MmJ--Lg8-TZ5nKaaX)|L#e!Kc+)HxQhGJREWu6seCo_ z3g%y-{41GP;9th?7;}G=e*rG#e%lz`tP1n z{z%&LPbz0TINszyf$Jd@PANBV-*GB*4U!d<%zO>SCxAND7{ZH{-rd)rj$Deua zp#E_G?rvA!uQUHPnsiKXG@=gnIJV!ViR) z`PL}^5_JdjsaF0)bb&wfdR-!tpLKnGEX4SiD}Ujv`Nx$%IA;Da?&tJ-WBqviKcRrX zXL=eV{NWbGWjy{1zkN{s%U1aA10K)hpVU*f%->v`-SjUjD1ZCB`7asYV|vd2tT*C6 z=iINdA@*GvbqoJ=mHE?0;eXO>{!`9%M)ULd-`*CNn~|16*3Ukme5 z|0sWxA|GP%k0}2Jtn|NZSoxoKng1Za@82Hk@n?SquOB_rrvwJjK%Nd?@2aA;-~oeU4MwFr$hOdS1o?K@_%BV1nW`F&&^vk{;n+ggyQ?g zxG!d@w-U_#NAd@Jh2r~$j4uUOM);WG`+Ah;?`nEqDB0wXUsZe`*NMbGp7nmj<|pxw zUsQZwqw%xg`H26F;`?fhXFVU8jPMhR?~5DH^S4JvBK)XgzIQ|Ob3b`R`sE2G|DfV~ z7mV)%cSiVL#rIAdPyZijj_~wf@V)GtV1BJ&*?(dD7RB=29s%D7jz{m~T!X5(3pk;MpKuK3b`|dc_ zUGTl^qvOUo21JLYFM*yukHk#hh`wF1tjlqYyar&ui;nk|yw6*IO8Hz@X+g2|^;mc6{H7+tI~q_9e~3_d$D~FV#G;G2g}J6n}>6RlaK` z)+9PCab=#dxbr@@r21nP(U&TIpoGVvMIIa2r=r{5#CcnX?RCD}o>V-<9@x%a-Cm|~ zx6@#WzddG_I01HQk6t$$^qKcw3W9U)=pp8_qIHz?fd|2b5c}@v0p&ByHQ>|q$3^&l z)n`)1OTT&|JpB@VrqB2u_-uq{--!M`>I&j_fw@j)-QBnYpg!-H- zSppA**mot1%4aGq{sMR~!q2NdQ*QhmI33|u0Y~f4t3DGmej3~p@t;z? z){p-rII_Ma6ROw!OTFXD>v|HCb&>0^g#8;>@`&A5Fgs;-$ZVHc`YpPnR?KG2wyX6P z#O9nQ^Gj*H9`}Dw<^%rBI14on-^Wxpp_b7fU4o^)U_h-rDby&P)k-jmi&pDSR ze!IqV+~?hh;vxF$xX-&`aBGC`S3JbL1HPMhg$UoJc#8QudgX$8c)iFvPSv8Lv?1!| z^?!g9rGnw<^Hh!TF?gmXIFW#l!Dqlc4vPN+1^5BQ3Fh-a0bc4z7@vplRGess&%?KX ztBlXWHz}6S!9I|MuLV~cpN6kioEU;n!^goD#;4#*6(`2wQ@kEo1(zG2(Mx#q;-7@VxO!o6!S z8SsqqnF9QP;@36UHZfw`*DP+1w8@N%%SNxbX@28O3K0z$f6x!DGh9 z;C;nsXW?V;8L+SXeFb>@1fMWAGX9fb#bi;0F{}k2>$(0(>_(ZG0Y{xPq&v;Pdb;;C|z?@J))V z7vQt-wctME)9}@btJmPu@Nsaj@hSLH#piJT-W0C~R>3{SCwaZFtoWQ7_$2%sxZC&y z{EXsrn&1=gpcPf8R0e(O+zo+5dQ-JRVr;N|TcPc(-1U?Vn z0`4$A3r}9b=S;$9;cLO|#;4({6`wN?pN5Zv+l)`amnuGI6+Xr59PCrA#wU6GvaI;r zGWaC?9Js~!1pJKRbIEg00)8CaY~J_erwHz_aQC%JP#@wpw&8!W(ggOkSR z;X4(d+XtVAZvi(NpM`HyeC{xO7QPnTV0;?BTJgCP@M-usxZd~_e5vAd=ipPku381x z8K2~J)v{u~cf}h_!lQet*7yYcjNlo*T2h(YsTP{@N?i*;}h^RifgcUCE&-wE5^s*eZ@5e z_!vBSo?KS`(*^he#pjne@6!eNZg9c)Jbb6(^DE)=@GamaK-_^8?`y1rCyY<>zQ(d*`Mtk^B>WtB-1r3i zjN%Ih;1lrU;4$N4@V?>;vhXqZ4A@uxQw4bZ1Ya=iyiXP2yTMuG^YERDFIa@n!?%D( zjnBe2DZXGGJ_}z99x*-*U#<8+IeZ#E4jwi>1z)Q80DhlJ@j8ALJY;;5*YV4W4>ZFk z;pe~^;}h^RiVt+cC*a4ygT}|;eZ>dT@GbJ}~OMzb(LbgVV<6;fX8w zz!ZEQz6IQGd=|b*@qq>SEPO4v&-gTawc-P7@M-usxYzg;e5vAE&i`$S*U_us9^;d| zZeCVgTLYhjp96OrpMalHT-yYnfFB2U86Si971yTVWAGVpr}CdHzz-;{?RVZM3-I0G zl<|4^PQ|q&@Ok(aaEI|(c=8IaorKTA*Mi%PPs3L$uAPTZ!^gpG#;4#*71yr9r*du^ z_Q_V`lfK)wtoXt*_$2%sxW)Jc{EXrY$@9qs{5ZJT_!zve_`)Q73_b&HQa)XPA5eT@ zhx5_}_-=60_&j{4;tTuW^YAU;M&q;aO^PoZhR?#+f*Xua!&fW5Z~{IJ9|zYPpMoz{ zeBm5?D(8+`1=ks$^xaX*iZ5J&Pr{>nvex(n{EXs*#7QUM$H6tm$KZX%2NUoy_zbvO z`A-z!2NWM{blxWl@ZI2q@p<@8#RuEr^YAU;D&w>8O^Ofp!e`-Y!Ij3R;j0z%d*t3H z((rL`h4Cr)QpE?y;ZwXXvkERZKIuDeS@FSH_$2%sIBt9ben#;@be~AT6X(e?<74pr z7knrNAA`?;OO?N~06C!eP?huUEWmezW5(y|b4!ml70)9sEA?%$A z_;K)x@iBN`@u32I44ypST~_{%0{npDx)SHzQGo9T7mUxtcPg%{gwMmbfR~KV!Z#_d ztB23R*Mb*~Ps3L$u4{!)!^go3#;4#*71xnhes|aLe%ba0Y^hn^9}94a+M`nA!vk9|RW-HBBm@PLOH(O@5)NIUbiCIdOdcAeC zYi3u?u9#gmTQIw1cG2vD*?F^bW@pXLn9ZA=Half@((HuUakFD)eY07!qh?3U4x1e^ zn=w0RcED`fY`@t)v%O|}%yygYGTUi3Wwyg?yV*9gt!7)yHk)lSn>5>Kw!v(@**dee zW^2q=n@yOlGFxf3!fd(OxY;tZrDkJhOUyd8Zr$vf*;TVEW|z$t%r2Q-G`nDS-t3&& zS+g@{^Jb^bPMMuFJ7IR*?3h{KY}V|k*%7nDW{1pX%nq6zFq<~pZ??~Duh|~6-DbPY zcA8C@?J(PJw#{s-*%q_SW}D0=%{H2CFk5f7&TOsO8ne}A6K1Q-R+_CaTW&UPw#;m) z*_hc9vresdFN2-j2Y!t`9lOH8A9_6MSnN+ZUgmfnd_H!B;~|cJ=Xj3ee>s1MV-Mpj z$HN@_;Y;s7I9JKR&rZD;v5g$ZFkZseaGc2a-#C87@jLJd*gs%j!%@xna~!|n80FyS z4Br26`~S)gKb5-v? z4*7XYhI6NJY~$dC)KRbGIEkZ{BLTmNy#hPT@oB~|tyb_I{3+IQ|xVCiY*k^7EpLI9>}LN4}@sAwe=J+JXS2+HO z<3}9di91Dzi(eK_G(7?%+oLR{F&Szj(>xWYa5(9=3P4eO`dUu>W}YdoY3*E zCdLPK%xfoi%UB`bzJ-dIV<977%{~L_G(~^v@)$_lLk+)aRw-e`>JM?^K z4daZCe?{K-ZXN$xG$T6xSuZ{Lv5tSr`S?*f{?9Vj;xZlAG@~C2#(Ykd@e_JpK5rQB z*YO_~sQ+{wU&)%5U9aOt`mlFV$8!Z@o~YyVsDJloblloSKmQ^adw<6HeK+g)x?$p9 zqMG04*(X2M@tGym@I%$e@5=7ptLLw!p1rr~_=l|B_AlsoR}15>+PIUk)xWEo@x6Aw zmhmTSTurVr9j|7&hHXu^`{bR~^RJIFm+$EKq8aqM$M{|(H2<#WUzcES9MbVI1AH#) zIvw-#4tLb=?R=8?o)e5c`5wz-ey8Uzs6yXkdU|`zpL9Gq$b5C~?k3{Ij??pPG@+P8S6gh^X`m~w)6CD z+dtcw-fpv+kL^J7_j-N@{onSOX{aq`bH9tVj@_u|FPLJS(sBJX;}7fjvOMFD>-hRO z;{hGtkftYD9q+89hySYMV`|CuAsbV3>|q_Zpo!VKU*3=JXU(^qvH9+#pWEJMzQdf) zn}(RNNgdbY8=KMb6-|uoeswv$immARx2`ew1s(5bWxQ_V0qT56$J-Yff7!+bKI3oK z+QqA!f3=vm z-@#aW&hKzB{+r-DzyHN}ST%Q75L55Z{N5P3+VuRJQfR)R<69l~DBV}COX7T2&tE{z zdtRaAE~(*1!IJ8(qo$dVUA`63cb$3Yz~>%{fUvkE!$J_x>24 zr22b08K0};3ToTlt>ax)jNf5nnTy@uc4ZjI@d+f`HA z$R0S>a>=|tpyTd-#&_y?Xp!;VI=;Vy>s{~dUUwfocY6L7)_RZKmp;iH_k2#zr%M^< zY)t%Jf6#F?ad!Py$7e1xw*8;Tv)}A7^xIwZ$L4++>k`+;O>Y}<%Klb;UrTLe_PF-i zN^<>C&wq*aDzm-UILY|6dcKj`_MWC=Kg;=AJKswU-_~)Wj=Wa?Mf7~9?Y9H-^x5{n zG0fMq_(xO!Q6E*`?cDy2+=J%Rei?j9o4(d7j*E-%ggyxGnPM|-^)^z&- z=O5Semy}TFZ90B!7d3oA$H&SZusv2GYxHwH{|LEC?EDU5di8q#=xH?8^NSZ4zo_Rg zrv9Br>sX${Y`1;L=aJmeJM=t1`*u6`==lC5bx!K|m{Mx9$CM^&D|wHeKX#4rUzsnO zo!0YH@h$W9e6oT*Tm19l#B9;?+lQ%bO2?xqG{4dDi)Hg(L%?X1)BkpydZg^pjr z8Xd3u#2s4XyceA3d;3^-tL?iJ+*|Cr=$z&JfcpL;J>PA6xRp5Zm(=%+Cic8O$M7y# zW~}}9dWIN3rkY!`^!Y)JBcGSvdAW{nBd=%k-A*68x9j<%*BIO5EH9CHPHw(sj6Z2( z*4_J88`m(l`j1|xhj#vI*2vlYM_xlayZ^|039eav<^2R_k84L&G9J|P@;-*M$1Hj6 zyz{2uJl}c3_)V&LcLL4VO+UlMd_Q>xkPXG9IyHhFvs|LIxf(Mea8f2@0>0)&*=Ftwlbd6@fY&M zv2}cqGLOGq&mWp6j`iyI%;h+{zun(WZ(pgJk`8?D((x-Y{~vE}10Q8|<_({jOkjYh zLl`hXfB|D01w&MODwSOX0RE?SnQ zF7}}nFd*#)p}Xu;c3&*C8$bG%R`z|Ur7i6S=K256IrrRmB9`{|+kNw6nDcR+>s(*w zI@kHQ?}1G!nczJ(DF3!9-_wBf>neR8=o#~WRC;y~#%7jEk6ewhbC*hwJ_0;?ypIe3 z{vBD4cl{v!FAAoS@;|N8I1d-8*Xy=>k*?F}lZeNzQE5*I@Rwv7??eKRH>z^n^ zGo4*LyU-vY0k*0BOy#N?(Kcj;vFIMnNP9S~1O5a_M^y4aBIe>JnN=G0! z=TVg&ISb{@x*UC_Xj>Y&9px)j`6Fi_H$ARLe}r;9rk?Es{CtgPBg*x>xuOK=Evo!! z&@)2MQ=USU>+$qo(XZT9-cu9f5> zQ>C9|+odYKcpdEUf=U-PLFRf4jy#Dm_+we_xc&m*_1M1yGIR_o_z|FgoVKN7B}o5P zmH#`^*J__L1F{|WhARJO^n2Y-mCh?e`L!zjodMwg8IlMDD~RoZ7Dt?hhTAJSS!(^ey``rS%~yhRW3kJ#$>rYgF-y>`v;_TcIv~n^e?P*<|r#Y z{#g(@ zn`|>~M!EjGp7J!)H(Kclq+kC{_@OQRrj@>af-Sw&p{xH6x!$|uFF zbjHuE^whhp^t82Bda}z(Pkr7>PqEqLr2SU;gfU3#ze!B%?8KQ?dMfR~EVtpD^sZGt z_3y3p+Gbbt@Ok%TIs3war!;0e4?%GwEL{`j6o|sAq8puH^rvA%p(@e#64De%6uz5)#ej2 zZDV}WGz(_3O;#B;o0*zx!A#p_r6+&EN>8)NGn3;5|M)j~gO$!)XQd}UXr-r|veFa( z#Y#`U$4Y1XZ!0~Cz5@UFm(gjZryRA?nH;AYW*U8wPEYN#(v#L(>8U;|J+Z<{Pupju zr*>HBDfAWi$G=Gvt@Om-Tj?qGdBoOl=JgiLw41E-#BW*YNw##RO{bG><6`2A7JSB5 zD?Qm}!&B^dj#)5MZR2;^1nlAdcxpt@IR| zugkRQXp&9u)5s(K@o(B#D?Qo9SLQOSeB#?ydWx;z>w7g4;2Hl`GF??$)6`VkvK(7w zRZXo`?JZ4D*H=AV-`3vP(k!Z0G}brOEpBOBR^Q%Uv!uRVRJGT4RJAPcXkFgX-qBWH zvrJTVG%l;Js&A@kZLhBrRj8<1w5Y1NrLKPQ^5)uP!J@XB=Gq3UsAf@1TZffxYFT1s zmbL2)I;g9Z@!?38PAf0VOf0+NM@frBY=f zGqtFuy-{;qQ`;fsLGJ5Y+neg2u5S`mjqO#-YQl|>!Sd#I$gy4))zsBhwY5C63=#nM zZH>(x5UiQ%s9DrhU$flIwk&$G9;lyALPGw_RadHIZA&xcTmvMaL>1L7uW3qVWVgsI z0bw029W_l=kU*OWil$0q)Dg6%;mi!VfvOj^w4;AwNM=~0dILeK&X#3uUHzivOC-NK z#X?Y8tAwCaEUannXax9@de{>?vF9N{dscN@FOAUb^-8&>mKK@_bch^n;bK}cis;>KnuR#jR#HibF1*0*&mZ(F2l z?Rm4_k_l^7PS?S*lI>(#ms{A7(q)<};6O^3aU75x6f((D+GJxhjDzLL4A_vys$^~E zI##rTE3;L-O}Y|T=ULylthKF$1BFe*eNW-UNi*R(=|=YO)E4z&}D>cu3rLA zxkN(@&B36nwCiCnYP{3aY6oERCaiC6X@0i8twjx#+J^SVC3*zXx-guV)ih!BEN{{V zfYL^KCylHXq8e5-#2HE90%k}dIWS$AU6Jeywu19I6E&g@tJh^U+6s}VTC~CjwhV%4gtc;FApvY-tCof` zEI*VXLcn}%owe4qbu`vA*^sKyFpLX$wB>azwJq(Od)YOI#1*(@v7KY)uZ$2C?e)#= zjhOKpJ63Rdun-TcFr`Ff_Nul9O-!5CXj?;-&0&C1g%Sx9#Zcz$$dUvMD>Pf$i<2F< z!}&I0L`lz0u`F*j6->uM0S$92lm@iWu|kpdOiSBRcwDk?20slo?N!D1g+vt-m1Xmk zvu$jyX+sM-B0L!c)h%C!VJQPtJp^T1b^(z1e&QiGfj$zjcm9M&o!<7AmcD1(q$CT(Mzd1;S2QMDM3(@N7MWlpX=7B^D& z%nu#QvV`%CoY7^jt$uNR8;w%K+XpoPIF8h}IgWJh>3XbQWSV12CrmP|F~thYL{zSs z0kurp#|jJ7SYe7|<(Yc=VXZ1@COY(`&$Z7!R^FNk%(CPx!vbQ46qWFF9v(vSvb?>% zO)k641&-{oWl;x~7s>gC1Ny=HWaw)KTheINv>;bH3ZnH^_<%Mz`DOLXT3Xc_2RtpS zX{~B%sa-0_ATu(mwsJMi%bSPPgUw_uW|hXe8pgS1{4mytbP~Wn`+vDhr+d$TEQ%s^-D_$V;Os9y!sWv$lFtMd~CTXy2?M3$`o>Hic9R zc`rwJ@pNNL6Wk$V7v*XjA(#~pE?$hL#1@j#<0HztWdR&_y(Bnf+J)((L&>TVE&^eL z9raSQlB~sz;rcpFqbz;2rtQ9@cZWEw688A;wH|J6uvS*iaf$a1Ynl)^nzz`909mOo7xsLYAq{RwR_< zAS18{BC7767kaRGzGA|(P-Sz=Yw4G)U_*}xy;e-h3@XI(Kbgf`)X`$ein4+GSl)_e zsuSek?3tq#S#>(6>rBzePDwwsW0u(rN-l;iay5xqJuRy5kl`tZsA3BUn4zIeF#WPt7)X#l(nTR?>8g^SE&484Rq5icbp)ip{oUY zB-4@A-j^I`3L8YH5U`Eu_>w5N#F7q8VNdFS^B!2_+7Yls4m;)^iX6h0DosIN!QPeS zz^x@`kos_I4G^hLsAmMoYH4GkX@gwVaI?y^cd!a*gdoHgZ`vrbjRhHJaQt9Pp%z=4 z7+v5C(G1s%$kCSCJL+5MS+T=3WR$5Dl&D%HCr!C;sz$y=hRQcC#$uhgm6U2tA;~Ob zMlCdsF-0ckN;yqn7Qmhv{GOajK!9{#$&9ACZbcJ>-?1E{1!`bG-B8~o$0;QRhd1wm za#2-P)ea^WEpBC)*@1-*xC=dkOif(_gf2tqW(X4HP(u?!0R;^z8`~R{vD5j$uL7rx zSBXq+n;@!yv(WG`W|h+PnoS7}`s%|lUkw38>q!}`VH;Rupl77GNxMeHQ10R2Beop& zKvb@N@#4nXM&(o4hh(}#Eed3x?T^%VU?IV@a;~~h7U*8+nz1l>Ru4$ls3j>=W~E7V zO|y*Q^(d4OQbs169Z7QMg%!jMVI+ zr~S0m*CEEo)~Nzswj5D~oM_06CKz#<>;m3O&2smbJgC4Ie~KWOe~X^nB|R8{qN*%3 z#7rz!>ROh|wHHgw-4>>m$`v7cB(Yd>tA+pYy`cvmF4y+1x3#(Cmp%!0!Qn!;h``%AAbqYNTaC54Btb zLinvM2sOzJ!a}P0;d_h9k{D6Hh?A(SDN|L_F-Sk!O4^}wxJ}59 zvQqHXEE$79RS83DhEg#5_Qj1fF{wBNdkt0cltVLjPq64=QKj`R#SAVQTH7)1Il)*O z()xyEmdSlylYffEpG0Re z2B80wXFa9^tZQn)9GWCDc}8Orojj9)6xwPVAWYIhy6T&-lGQ}PdR3ajO=gt2$*e|a z+bS?i)MBL-(?4TZ;)4{hs7l(UW;kheSpPPuk$_pcV+hlbYw-$YP&}lAT(~)%JfhOG zEXuV4m({c_rS{BOK`pI`c3v~wBQ{L5G@q$yRcO_O)ijSzy-49nh7^i=La5*(DeGd6 zvZS?wMFxb}{@RrplQ6DA|co`C2}4Y;Fr89eQ~L^tA6BcRuQg}eCX_>bs96G+RFPWwNuMY^ zU3p6gF27M7W1F@ujZpfp`yVTQ@Ikm^?)GyQmS0l*<|0x}3vx6m>oVOj&&o~9Tcj1v znZ%SP^w&WLirBKQiUXvrcCic^lY`q_xN<<$wMd@`t83EkmzqqKoEOfV$-NWIwv#wq(Jhoa!Vd@P~6pc(5gn&9VSYNrsup&6CSL9DB>0 zU)*r(>|1a1S%0_QI_HjCZ@>M{+wS!F?#R6r73%+6b928iXO7Qz>utAw0bls59*tei zXPR1bT6hcN@_+v6pYfH>H2!#%0#C>~aBtYB^L#JBmHsAl;f}IL2!4x^`jbk?sw#O% z#iabJsw%&?vfRv>-<~t7y}8dJh7Gag!gqytl z`!tRTEY1ZF9(?oZV)HM_3~l-UoTA%-7c)-3)a`dTHx_Iah24jo8>6p$95zOzgi+`3e&4xiy~EkFe!8=FeUWo} zPb9%Ymd197^mt{eI#i@sQr= zS?8ds0pnK!|>)aG;Nj*yAF% ze61%xvS_~7a0YWa$0P=$o6uji5P=>?cXY}-;guIfs3OyopC1#Be3Z{k;PW3s+;ulT z)9|SR>gu$!n^X7?}S$#`Ny#TAJWg4CN8IHI?EE@ zmh~CQ`rYXlN)wlUf&PLTrbNPQ5f;pM(=P(%5MZ)Szb^uVzKh+lLn07+Uz8;A>`5O4 z%x2O`pUF>LLPaW29^wgNCKAYVtp0T}u9hrQ9w_@%xc;RqHWL)jOxkM{~n_g_UuZb3}A;M#J13@!?Z)fAK04M ze)>@2JZ*@!ByET|!V*Ww_}d%8G1!jry_w-Ir+92O=!BhS7QPJ|iHQ{d4$qOGxVDJ) z62$Yh#y#W6-&0y=KEg#)-U<76jCBznu;VrCMwSP~H9Ka(gA}b2goq50s2^I(vN;#yi4~X>3nl+9m?Xd%9N9{SHb=^r|c{I5B%a>0{r~Q zv&sL*pa$M{j>d>Y2pX zLHmA()TzRocE5ex9$hsq1M*Fq3p$TJKh6g{nMe1fo-w9)cVFsl2o0u*+Y+$``Ue|r zX`{5h()_2#8ffqK|8#83rlZwLM}I1UPsy-&8uPFAzWbe4-~D5(z9XBxy9Y(e75W{s z{wn=;tA77@6g2fxCT8E{Coxc+9Ta0E|FAXXw}#Qsm65t|P>lS9`T)-o=IAy>C-7B9 z4tRH)I1>X6m=8u@GHJ@2tYnclX>9CMKF1sd1i!|v6v zYXNH?bNh7pQ&#&iskASSvBBx$W{k6pLEmUO)&l#7^uJ%Xy#qMwtoEaS$o6QP{Tc0! zsCIwg_)qE)bbphWNx`^GokQD+y!O%V$f}Ppo~kKRWA@9iiGw10m>)Q0 z>VbX$xE-KlUTjm!N#ZqDpASKoFEMXKCQCo1%0}NyU6K#z=q%=?K->ZSy!vt2#0NZx z1)O~xn;0J+j^&~)&RIvp7}x7683$x*nsTpB)9>G8JMuOtDnsN=`i7yla#6|r_tgKK zp**;MXVIIU^r055zh5v6eurhN>24d`Es*UT>0_LrLHQP&4W@fF4XK}|Vbs_^Ps8v2 z)$GSF{rB$q9`q#}4_fWe{PtM0`PQBnj`%|1pCHw(#3bOUeGLCWJ zE9wzPET1y+A?4E&1B8+F`^9z{-$|c3LfVh=pXsfZ{D1q>5S;r(_1zeo7T#1DpJ41u z->l}*5z;>wA+E6Sr+$~VEAbylm*coJ@!Pp}+<~6NF0)@{qraU3d7S?Yc^FAp8Do6% z8;R>LmWNBuDMeefJfsh_%Ollcv&T(lU!{pp*4k+<`jk9e^Q5mFA`jOBDf=PvaBcmx zJU+R_j+^qJ9Bh4Gqx`W;&QF2OPSIJJnwGQ^$U((l=`w~?zT!9U#U_a~EyEL7!?^N$ zh2Wa#u4yXv;#!F7qPhQ})=7^ZMBFv+d`|4JaC63d5Pzj+GlGFN1!C&zdq-5VQ&7Zos0*z6F5kIxi7#56Ky;Cxtsc^mTqe&Fol%@vyw zo4v-^OvV)@czb{&uvw%P%t`NqO}h(j@$|$>MW&oHUiRQeI8y4lc4C}O9!ZD)jr1d> ziSz#n_=dlr{f(rR?TIIHmnSF5%Xia{$L0xNWQr#TYZ_N%F256lc%Uk$DD+I z*04Rst)t+%p*)k%Xb<9$DP_9@n-f{FV#sP79PI~KGk#Uhk(rQdTC%_0>8F5?^MA&W z@_$JG2<20#yZkqWgL;d;2)xkCszoBBsOR!Ru8Xin+9TIjSQ8z?n#f#VnQJSqk>1{# zxFF|OuC=jF;yMeyKOWocT1Ok_9)W+yCy2d1*#UfV&Gi=B=(RuBT*L8joo3=H{5E)8 zow^!4{JpVq@(Qk%ur|uJ;V!2i0RDR=9q(|B>)a~)y+VHie`cSN2Is4DmolI7>YC?M zgORmzk3y~+Nz<_USy!p|{P}virGE8Q>Km?7Uv`!H+^f`k|9pMQ z#jDhxxk`QCRqD52rM~Mb^-Wi)4_&2x&Q=Wghff}7_&QpAWg#Cce9tuS|Hft?j!1mi z;ci>u!*OYS&gkLoTb4J~`G~^Y^7rAa)yJbTA2##b8pCKJ9yISk`}hc)ymcpVn4Iqe zZOa;)<+o1}DGC68kL{VT8{1{IxN9!f{P^55uX!-VS-253>l-USBKW zaQro-J@Nvd(WVT!v3p~?k`2G}HA9l0IwcF0&cBh_XULfCk8cCx-`o0I<*=Xf8RcgE zf8V#K4_n#qU`uPSz_WT@6-7b~bvsmslnfOqCQkR47 z@iALD=%jsIvrB&ipYt93X5Kmlmmb#m@lAPN(}eOQoq(%T`E-+xYKkmdW)-o|Gd^h-X| zdh~Y}zkwI{31{+|)}Y%jM0wbx4{+rwpWdqEkrvW;a`iX(VZZooahu+dKaX~GCLZL^ z4drtT^u+pf^hZ9&fG<0rWBN4Soq#Jh@c^z@8Tt>k6+W{L;ocv9?+Aa^67<|9lkypT25@t% zcB5gJ%;Ps~B_E?tX!t!Eemm;3Z1CWd`SeT;ze&S`Pl>-_D8Hi@4&|5cKDFB!ersIj<%!?o8zRq9kc-`ZM$NLz6Ti)uHq>vA0zdTQrr#a~xlyj}v%quSqR%~` z@?%j>{_&glay+~H_4hvAZqHD9`JPj|y}Nsd((CRSO0Rp9onG|Qr166!vFJ6 z(gD5Euee>RekAnl#eAUZ@!NA3RDSFc1wT^LJ@UAQN4fWi4Sv7MkHt6VxskgdAD^ur z{4lTPK^%|wsQyQGYkXa3-)Do5sr*>ThxCpNYq(aFC+9`b*`V@c_iDI>8gH3~FG0O+ z-W*w|@?#-yi8ourWuknKt$)ae`LR1SoJZjuF{r=Ku^rwYcS^PA`|rHl&Gz^$JJ9Xz zvgOgAceR;EJII6a(ul61a^kxSEjghc{7%R=+sWVDllgHz(uMlEVePB!?a@!Urq{3O z%mp2rZ1})G^JBX;zN}$%Q!aM8J&NvB@NcIp^{mR9bfpdqr7QK!P`Xl2D7sSn6kVy5 z*E)-?)IBOc7V;pUsjw%zJX5z1r7LxlrmJ-rT}{L28YZvQVe(4V@=AqVIBrtOzhR?` zc7goZ4rLeE>XP%Z3;b|=;Wx)YFMhiY-?WFZJv!fyJnUg?Oy`dv54nytG#>EB{#-kU z`T-Z(dt1%^Q4c=t^MGrksvp~+@pcdO11|I@@uDAV9sqri6Z2ys4~_#D zAK)Ml=Ep819QrSTJmL5FC;1Ghyy*vBg-WlkT;c=XOpTXvTWD*Srt)KfU-s`(a4CZ* zFSp=QE~q?yOI^aHoK^T!1~mMsq4MIp`n&;K`{OD<*01PK=?6UY!avfVazwTF^y++{ zs`vD0_?9p`WQg{?z{FWc^4e5t^L%#|y`rWADRln%V(0n!V8|~{r zcbcu=g(^Q5a-zIaLK;4x;R}J!=D$5Qe&ivabkHs9sR!_#enICkF369( zHwQii=%HN2c9ieb{Tm>nSdUMM z;?qg_tXBPu>w><3ig_pKAJ+waZbUw&>l;uHJj|zLpuPe19mvD~@o!uZ^-U@-?JbD< za^%ChJ{$FADo=YImyP;4$am;^H|l4pd`%&M8`i;m3bbSLV*Qvbg6zUsL-+_Fgt`DNVN#$J^P#;8n zIr4s8pN;x5l~47cJ{$FOke{RL-Kd|X@~QY9>qfm7`CL`+Ig9!`oP2m0hU_>teB zPky`gw@ZJ6L|Hxt3E&Xd;=@J4b@)ug2fxiFCgH<7qP$~@-wcy?MuAUmG626opJFmT z+&krhXgogXhcXiXLwFrE>Nk(jgK#WUX=gt&1=l%P=4rxzGj$rW!f*P>a?y&kepj>e zBGT!)d>7LHA3zk8a6DwC#d<64_=1%dws%g7KU(FEkycu)wxu^&X-B%176Vq=G1p3q z*Q~VTFS&5`F<1P0VnzyNNkPc5gqw}D=YZ?hI%+sl3=~n zhcD3JlL_V#$MDB|7OTgQ*h;e~$n5JH8;n<^6qq;3BW^OMPDX9={Vl$H#h_zzGTXssGmP#k^b& zH;eD&J^m2{`^)a}cfwDwy}-TmzkzQ^DUS)bApLjsd;Fa~Tvx9aVoe8{;NJRcJMp~> zIDkw3`L2Ekzbgj*@cG(Fv`CSy)PG4ruKp~**U-WVIjz&YB(Z=m^>_7q{Oi~s{LMEi z@r`!>Kptk|!@KzWhD@9B=#YG_;WM5EShojY!1Fi6mFyd7>f}*;_{Vbi=I>(86wN|> z?<0ur9Mbg3A$;tAMab~OBf`)4+f$8-is6-SA4**0xjWCy%`^F;RgQJBmAJFf$@?3Q zSS&?k%#JZFGL018ul~y4$DY8sJ&<)fMFwF3lQ|4#tqmqq!}x~5)Z1Wu8YXKPOpy&H zOT%OjgPCH3$<{ElhQh4*qYY-3hRGcU^KUkoTn#g47|eHVFmp7Fe;CZyZ7_ZfQ>bCG zlnmE2+F%L^qvXv)sx|jZ*-nLw%{va%lfF~&c2VN&FrD>6XZ!BJFNou^_E1>H$ZFO&&cbRmZ&#LQO zQP7L~Xs|il?{gz9G)z{s{_?_Tf=1AU>;&U%O&nDVwR>W547ec>+b!D ziE}z|&M|RT92jvI?OfxX6HUT({!zA_Du(ne``se^s*hD~Y8X@3CZ0kI&#Lu=;r*2$ z;w*o))NyqTcWd6FUbT*6_Xv0V2BiaIQ84F$n0nsf?Res>`3wwfAZ$LrfO|RJu@wC9 zTBq;;rz4UDU9BD9J-)%FSWFZK?#adYF7%JWkI)tg|J=LrBbKkNKHel^0x!Y#qbz{C zRt~_F;Qn=XKl1%ER-YUcfAS0#H)Ib6Jh+qHIi4{6&ecccvn{ZrL7(Uzbd3DuQm>f$ z-c}Ke6^Sz3>#r?Boj)MzjN%Wxlx4v-;C=$MZNa@hJTIf=wFCF9sP8n`SJsAA(D_u{ zXIzEnidarNb*6;#X5dcZ<{-&<{7gA+g&fytIrc)1JAN(Y*nJRm!H)eH<4T6{noscy-t7Fsma@uM!5ejgQm4fgZ7G_P6vrG5TyMa^E9iV^qqkk?hiNr2b2^_e}=Nzi2C8{H1U# zP2UgPk9&L12?yW`qhIxLzRATH$S8l_lVAR|48JidkYkK`EC+pN8cw94bJY8cQFC@1 zqwnACUk#c3QaJL~;Rkr!!sY*waKj$9cW(jxxNj$U{5kHz!M0$Z8>6p(jC*B?S!Vyx zaYjF8@uRQcxh6dKDDP1Bh!RaxkoZAc;4h{FglRu#JvTEOmbp@-Sm$+kJ`6`ToEgyz4u3ULO z=%^Pw`sBSxM-2Qfm?8C)Q4oM1TXY{30wB<}=lrKcRP(Q{O$AuSsF2fJr z&dKu6>++x~Ck|6af&Ic$@Hn1}`-7B4N%X7PqWpDFKE~!ODVOh~ND(E-S*THyJf)c-}hgs;emEf5~?>@b{X)$={L15Fu3 zs!LY{R>6kw3|T>*ykF_SGYhWhH%|%P#{}OoW9<#l`Q-tVAC!5bUD>pUOz>~#t&lXL zY>wg!HuySu^V@6?>0vfVeM7INj+G4t61gbv=Dp1yK(EvR#Jc0c2pkkyu~%U0NCS_6PjD!@BlBVo z5d-~hqjzRl%I+ZMwf*qRaS@9dLtv-G2611PcT6`6gE;aKpT-MCR@{KC1m}Ar*@yv( z@vP*kpePT(mjoWCJq02&f}zMwDX+$BAlqPNj=vas2|kt+zZv?Q4;(eZSa1{X1nata zkL6%Yo@9S=EMS~Qzv4%~iH)&^ursG?pN^9W+GBp}apD6C;9RMGa|D&$dW9 z_JU{E?C0Sl_9uD@`s8zF4)kFR>m&EmeLVZ3A2?+nKZy0Hepfh%PvOV23!4-BU<)NN z$i<5Hp8K+2AeMGOhmfN#_XWjs_kzC+>V-T94kQ{t51xZbcrdqB(_cWx?zdnk_PNc# z^Rm)^{9tBSJ|DY9-M8iQv5XTyqkv5d+7j&0)%jX#VR|!9wD2hCkluDl?o5cb}SsI@;lLYOV;1@GT~9{iqwn zdWA4(o5kny;$IS(k;Zgy1p10SpBO~BFSZusQ=MK6d`8(>Soe?rG1vd^M7gg@d6grYa$jyHTH;u1NBuurxxcj9>` z;4qy3wtM3!#2o>t*E4KG8n4&}ZcnzEl)4-6UC`qI`3t;}$ToSS?`9w6o8W7bJU#t0 z@&wwTlXU%74q4!yg3H;R<6CaJ0@g?F7 z5wA@xgq}UPi$05UjIj#OP<}<~-phOR)RBSv7~Laa2e3=PvOFVMJ`&|!$#P$L415sY z4ckCp^nJ#wGv#`dzHP(%@G0^TD?{*SsYRO;yQ0r$6K`SpHq{sV0WATv_tBTHMl4nwz&s_( z6X#Lxmgy~^iER-->wExwUPis&p9;Shs}$u@85&a&xs2+jqIXtzn6B_>X#^JjNyoNH}3 zrQR1bLKYv`^!`QaJw#bwG*TZ{dLIM5FNNOGN5rZ1-sQvdRnP?vPK?pe`=?=M0f#5@ zjtduk z3u|t+M?6H|890b_I_7!m5AAaqmjw>s{Q|&k5I4ui0j$4Z7nB`f(g@G=Z1^0Ex z?nya`xjV}!J{#g*2-lj%cQ9wIh0j_I`Syq)>V3xc>=0rl=^HtJ8LuIxuEzT%is4JZ zr@vOX`mvh_ox0002Sg5nmZ=T-##GD$A~677)%qX24SxSlvB&}JV`%?b4%_5- zqE7FpUDjf(Kc4}5)Y^gLj<7MUDZJCmYT(^(@$C;f`#>T4S=TFT7G+KXA$C#(ISNy@N=9yMcaK#-)fG z`HYr~6QH9_nEzey*V0d;zrsAocL8j*AE#}RZRj(Gw(zg-y#|^9D`A#WFKm-I1)FoT z>?rG>5dQbJVP31kS`$9J-`TMr{Rb240DBO=bfr1xJ>!Bru&361fO4QtO&I{6fAE^> zEY8g=*K(2jqiVio504tdr$_0BDY`@o{XN zq#V{a3c(nJvf#Igs~_W3t@+*TGhDOU!@8 zm|N9aNYW}}C5~CW=La9Rg5#FY!EwxT9%eibAEVZiPV5P+3g#4T6`2^fF7BO0V?o-b zoASb*j$^Lxp4^tc7}pwwbED{cy6_uMeBeF$ou|B6F7i)tan1I0r49>qmwkRxJd&Rgc3#W@oBOzpR`7_-DM_B3poF~#ZaMjo=_ zzVTV^DRXT=ULosTV-)t3Z<2Kv3i_x|=W*_}M85)iJ&-uh=l-F)^NcqNdVvS?qdzXs z0>p-`!XFe%e~5hp|AuX9PLOmQ5ak5{3GaZ7xC(rTL9veKd$fY0;YBr1!iLd~`)twT z_qp~+V?H|L{T$9MSVKBEH}QQ*m|Kp3R?aOl)`oA!-e@p~^qTV(`OZUZ4Oxizbj-W3 zDZTEpdUAMD&rN%<0SSX{CeI#2|NBiV)Nq*eAgwQhmvK!n9yemWt12E zg??vLGtUvkQJe)_`g@Vx?`#gL_iJFRj}j-kU62LldgIHvA^5ul$3A>_nsIM#s9;-y zxVteH+~6sTem@Vo2^_e*I?o5X24K?%azpVa_5S8mJlDOpQW(W@Z!-|N3Gd&y3A{q4 zHa%zRIM8G2n|!XHk<|Ms_9yotv0oMaY5=;u?2R;jiLou`eML(QI)k4M9Jq8*($b4O z#z_=>#Cz=YR14z+Nl(leRUL|C+4fRzz_}FG$J+k9(bx&brzMgumUF)2p7&jdS-)fM zH|jm_C#YAw=Z$f1jLKAd-n6;Z`214ud1JnV?s~X?%DperFKs1;ec%0;3L|T4$ybQJ zj=o6xx-0A-<&41l*0v`0%Kf9|I!3I<#jWXyYR*C3unoBmJb8QA_y*p)^$#<{@i#FZ zUO;U96_G91a9dJWcOHQqZlRr~hGX}^PCuvY)U>~%EveO!SC)q5xH$+u`e=s@U#Goe z?sRN8tZY`U#}-LHhnVU-?f%@{X|SaZksWt8%Xd4`w*9>lhYPj>Jd4+KE{ARfa4Z*D zo5qXE3dYXGl{vIm(CVd)uet#=t_O|S%g8Ul-ZtzkU($j7(sGfFy!gsty!!xq-m||+ zUJ@5L_6weeJz(v~@tj|cynsD?vrlvuN?cil&p(Z__4}yjJ@Gjr`_T_P`6~}|Ei8H? zA3hh3y7*3_IvpR2bd zdu2}adx$4+wpg@ZWSZ}ugV0wvm1i`mVtK0ext6?c?6)(aIb-H#XnU38OAe05=BFmTXuM)AMMTp#tsHUF{s;AuS8yU=qS`i{&9<-{(S@(AWc zmd^LC8j~2Tcny1ohZ70N%opuGFDkZS9eNYa+lq_574LfTEBdhiS^c;-e@0?3e;(q; zoAW8R0PO2Xbju0oz_HhubUws(+`q2C`Ao&Tuno)!(H|ie`2hQ0I6p<)a4~Ow;v#%} z;mUXYIka=c+FiioS@j-d&ph6BL)r7a89`C=D=B}hTVD8A*dxX;%kjPo?BOiBCI8mM zAnP%v^t-;E+yh+l{U1lSJ-M$RHxmc15x1Sfjl=wh6Bi49o=6nrVOt&#UdxIv1CCKxZ(^+aF;)$nLvU_4 z8u^_Vly-?Z0qF$SADkb+?{4{+}T+Sq$@aYdlNGWE1CyqrQH|WOaE7~r zn9s(*H%#=%y(7-=Jg=eb)!BVw5WJs@!Y(UjVw|D=N@x2VXNbc}^q%x~u6@v#IRoVE=f%6l=NtO*LE8hq@(ynp2{f+6mYuKZQXtI3!zAkM+JUx;4MIY|seUkbtA zFL%dRLRT66p>i+q-wynx--5s1=3R9-G06S#Rj*;(VoqK8`<)L__t9^j5SX_XA{Nbv zE;tc-^bF>sx6t;>XxsTyFYkXCwI5&{KT*$kRpwuw*EPDw2_#S;H!~f`Z_^Fs$ zM_1g-^XVtxxo$Gry@@~i>>?`VhF~mE2xW1sz(D5|yd~v_b#WMxQ zD;P`f0ly1!ax+y}guDCxc_gwHEA&ybKmfRDsRcDXTaSZDU_X5o2 zwC_0XTtsF(?u|gsyzc@yUo?h2S|`R8{943WjF=VkQeP;9F*hfA6lc;1BVj5-1C)jC)cM! zh|^oKUc>%}+yj0Z@o5qCt@eNe#vZvR>^FXPdzkyd@eidh_u+k?>V2-*hspEN7r0*J zdtdQgo%?0%*E@gZi9MKFm;?OA!Z*Ux4b0`wzwbqySgvAN+{xJ@_ZOXQScJLo;>2DbF;f8Oc)-E?pEQt zr3dBTaFldSFyB4v@T31&67NBAq5o0b&B`VHkKY^nJ@$4GW03~*|0dIF&Hk92pUwHV z-&tLWF)iOm+CQecn(yL_Ju2LDqp*?LuCikvS2yqsnDcPH2QeRFLc@7K_saX|pN^fU zuc~fHd>ix~6s>&kFX;%1#|{mn;Z{jQFZT@|lkw?i(GdRv?vII)ZSfXY8Rf9xCd|*( zko~AH?>6Ou{sYui9_mRiVb{Yp*B6O$(tGTE5sJ)sjQbs~2=+-Z{^Y)zr1^vD2DZsx z1Rsz0HA@{L9w`vO*GGAYP1Mn<2>OJMqNjcvj>D&+T+Z)YldPB1G9H}Iaw zT+%J~C~=-bJj91KWea>5hd1HAQ>)X$N>%>&Wd~8;;#gKf(A5 zWAP;Mt$gPn<+`9WaV}N$>FDl6pYf*=yWR{xzM)?jrJQBJj3*(FwCFeb8DnHJ_TjsDkzS4Yc{lwW z(&2&(*aBiR#&UqqWc<^Ao01*sJ#oZ+;M?6l2j$WhD&EBVsoyBt4Icj;`r!KJ^PE>7 zn*y0-R+P%|;HsDpJ9`}Cjcb!fF-OeAy5tLpiEh4sH+eKlf8dQd5f_N_p*taa%qbnQ zr|}NzgF8dfCorEJ0Iv%8CN5&G@sKv`+wG%n zXVUg0vCd;eBi^Wh3oiy6EHk=ji9~F6&-1&N>Dk#`B&?P26YhgB{$8 zb6M=o(f38}C|zOtJ^DHNJNjEWH__i=4-)fJjPI&8ecdYhx>dq&^L4X0*KrKVxeoY~ z{iAR8%l`4M3bw@>OX!L#u3&Pj4u|i;(2{NAwnR0AxMqIQB^z?{RM&&r*Dqm~IRdg`Xka&OO z8^Dvv__yL_j1k19Q77(F-6b-B$8C(6$30+Q^w;C%eHQp=H|4=~JNCmRok6ic#<$=* z!1$)~f2Hn6nLJ+`^qucE>L!PIzP9qU?}Ux--Rzb7w0&}Iu$KCuE+D5gGcDIXH({KT zzq{1ljl8=v59gp*pBmMn5a4m=nCm`_p=$U&*xR48HSYJCHjaJYGqi2a-{$`);Fsm|4_zs# z3#A`FDDeL1i`~)teiDu@ISo9Ite3pP=R=>^f54v72eembhtx6jFZU#-V}EZOVok*G z3w%6tI2)p$tk{qJ@lM$E8jh!jcYuE0wU>AN%LRQgd@1Ttw^rBrDqwFi-c)sN)GfoD z(;I`lq4&Zl#wo`1IoclAiR!K(=7)K(JJb`7aV6mh4_iM4U$TFQybd__O8LWIlqNoc z>>=+hjx*p<>2$5sX~4f0@o5}7!F)#98n2xS`Cu z^91}9)>!1rfc;za;QR)1lC)zlOU_*!tDrTG@l1I}Zr1nIaTivWuT-+<8n=HG;_ETv zcS~M@TkVU>HDV#|2kjhc2O;@T_i=>_U2cL|)X#<&DLm=H_ zI3>+~@`8LX={DehK-UmkLEh4x@@=_8b%!`(xb6Tab;q@rQ1|npgOb=2@R6%r7u9~T zm?QTxw)t{+K8P_u9^^Qa=S$h#d;G7XpdJ23#UA+PdrYOj!9B<`alMBj=e1V#I}ya4 zypMw4C6W8q|5cDYzr&cp?}Ut47oUOszN69xJUXAvynMg&X3?wW{PIekb)ro-<4JsX zL5A6#i0$S5!Oa49>G6)_mr;lNYqUw8mvOx0fp5@1iZp|V@`_cSe3nJG;VuX2B`oGp z%*DSj(=7KNGJVQVS7=>i5(o7YT{Mq-$)?{`&pX(Ddxd0rPTX27JM2`ukw=j*dHz< zE|GI2?%C|(x~%gCyr&&&EyIbkJH{)IJHrO|l8R4+Iy><$`R^l+;61i&JO{)6#^VFn z?+}iPzLA%?9z#6fHoiPA+L zM$83Yi?RLC+~{W9kJ*p2ORMZA^S$v3CiMO2%Yec8u>}*_!8^0S7pUm_m&@qWL!U}H z1-6Xnn*FzGUBZ6jk3x@|Pf_RcxwDERBYt1eH)1c=3%df_ef< z(Jm-P6b`S$KFmkbf8*>M@(5m`{s`@w@+vxj7#ioQ@*a@JjrQB6&wQCNN8%##8|D7_ zfyBNmz^ePui>5Cu-1g6Cb}D~5P{|6f6Ca2PEmHah)R zp{f5bq-hgqlILGIx19A?&^APlu&Mu_<#?&1Xq8hvpDAt5QT=H+(LDEmZ;D%p-4>CS@ z1ADU>^b3?F{6dE57o;pVE|EUL8fy(0|G`g-JOAM=jCxyJfw zO=1(y^0R&#PxNxG{^{1lPR`Zu9ZIxb?sa$n^iX2Y<(Q}Yr|&2BU9QgPKJ7^Kot~cP zKV6hKak?gP>NM`9a=(>(5pu1D*unP^VycnTy$u2<=+&iQ&_&+Trd|jWF<8hfhxoc)GVb`Vgzvt*;Ti>m82c z>!&+T0KO6*?)P@#gZtzuCu3UyTZ33~M`|I~g@suERmP`-j$Yx4txY)*YaG$dI}$-L zZ#?GuTEN!%`?z1@*oU=S9exky4!O2Eh_zFZY$vdutBWlffjBu>M4E$QWLLy_4`UNI zV2^x>IXarCv)CO%`R=R$A1 z#&Lpsgv`T6uooxg=fJa1Ts!*Zm_u9yUIcjaQam5$YxHbsAky_Pku-Isb#bRT=Av?K7rQY-1 ziP(wmL^VFZi}hWTxu1rZLjJCrga_UKtRE!oqjC zV)MNPz#lz~J+J-hzAt$g^quIg!1Lk9eva`~dv5n&;8b`2n$jlRZEz2+6rb=;56>Bc zqUdPM;W)wAj5HckaHl+Qw)@xz&#rxdz?6%69&r?FIIDHCUqizw+(tc`gdB7u?DHbLGg(v zu@PecXC-miIPs9b=&>ZOT-pJ~#R=*aRAU^L=MU(!Umv~$LcH+4*t5YQ_HLLi_H8H<`*Fv0 zPe0O$Z)rR)yVcmMaUAD96XRw+8?Pr@`mZPISH!_O(#z0D6IagkT$$c>}obAn@_w1K6MlOkWTBUI2YBfTkBf-_fmN z&(TAmFW#W|T-7Q9`|*2Tkf~gQ&VUTCZz^T*w@L<=2i)D4`$YF?*bV$nd44tU$MEUJ zrw=lyK_7ASu@!wBvdN%F+`0Dh9cMHJ*6NBEWPe7*$!sEq!E{sZGW3-ix* ztZ(SCjbDS}LQ2;-C z&ug&nv#mln@otL&@_p}RuRx`eTihjkZp>@r@*owXUTxrFp_eLTPE|9okak&3Y-oE~`}pLX_j z$QWntk$U;;NZN}x%e!_C*z<9oHxpMZ1!MVn$Z|7&hq8Whcs+bR@%E1d%@_xWn=)~( zmjT%Y{^M_Yh=qhBEQP4w5n{P0A$3JNi;41JE1fCS~*FWF;H)1KU3# zWpl%4$|l43g(C;H;fkd4Tb;pCPJG4}x;~SX6Xqr@r|q13x{m=r_nPp_4u)r}uUri9 z{Tmsene(@89u9mTvcg`EqZjb*?<1apy~$@9k0OqF7cowxHtu^DG0wY)Z{9^r^Dg3< zV~AyrA(lCYSmqdFnPZ4$%ySp>%*Bk87$cc+Po7WC8?L;75R8);H!&7s+{Ac@K9(_2 z!sqF>$3=*PT4{rbgLYE47#r2MtipE@Vh-SfURP_K$8>%j>}V(8S`qK;!FK~bVZe8E z#~r)64>|TC-Gq;Uxv5LXJ3E0V$an{`J%Mo;Sa8=LF5_&YE?(s5NB?`GU-O8-L6J+` zhp7geA{xeR zthyoWTZD-qWvn-6sygd7dd26;cOcH&im4WNrdW_WR-$;6V@O$~c zD(DkS)jloGcKSpu`-je5u~mrK5PPYZ?d}>r#|?SzlJ<-Cut&t<{~5Q%Y-|TxaqLnt z+g)F$Y-!h!Sqb)6deQIRTQEl9%RLyY>RBHCjvQpJ;E>u|~{g^G9Bmc2FeB6R}f_yF$=i zi7{_n7_hszw;p+2?AW{DYe2TI47@JR0!N|TU&S~h&7}9( zQ4>Z~QV)5MAL+2iRD8CI;{vu=H#l9~hVLfYH~XXA4(5qA%yZS4=NkIw7ncP^-i?U? z#6f*B4#FN9)`%-xtvKkgj)VHZ=QcbmmkIynJKxQI8B_7hfX{dtwXWUtZT)MC%Mb@S z25ZG_Jo{2{kpEEh<@4ZA^@F$u=Ut8_#$EFFWx=ELm9^mU9g9cEekWta_|2{mc{O#?WH-z_eH&&=z?nM94K#2D<27vZ_{Cqkjfyp&g0XW~9C_(ja;=5stnI77ue zR9Li{XQ^UNaX|3B5@!%6S4IxEhmGcpkkN?Wx|$2WE6+<1U2K;3!Ot5Hj0?jb&~Eog zxlUHHHtHESUhI~3@Xt!N{c9m--2VuQJL{9YIYg!L4UC^P7(bvfIu-uq`zf<%m*~G- zjz!!FV4k*1e=;b3?O|HRS%?FvL(0*=1G;z}cKJi456tD8AhVtL-DMeH>9LkEci`^x z`2z8a47qQTG#6mj}3++O@)r)v*=cnVXU+Z`a$lptR7fdAw2y&8x&F+M}^*JU!+fx7Q6e8ku91h3x$t(zSl#4Blxr|0_aKA#srKm4FSjEC6zBCO|&um-OY z>%e0SJa!F{(U3T$xZKb22l|e6nsLer#3@|c6qgMK2H@N7m`IsiLY%^J%eW0|2M_xr zozQ&@wtGCUTE3e^a4zr<;Bzlx05gtzTl%bi#xF8nxv{v+NV#GxmtnkvIECjPAM)FZ zSGdOvdoE$T678(y-uce;4#;V%=q}%Z7-bJ)lpTms7_%11`N}r$_{T$+nD+qB7y$e- z4cdLU_a>iJmCxhtA1o}|H<*EYgRQJbOv5$Ur(zn$EsSaYTq zK$5iHakOiyUSD9|=J_~$VHWR5C29XMXy!e)2*0HbWUzno$~&pi#XK*+6Yqx`nQiBX zza?z)L>qh{=9<2tM)K8f^24ztd0LdWkA6w=#Ir!n*UJ8X3`bx4I6RcMbGWZ+J?}|9 z%Cky+7uD#I_kCLV%sZY62;cV3i!q1Z1XH6v7V#;1m3% zi3{J4PsQ)LcS%{3HV5Q`J0+=ge6B8D1e{n8@O(eAzi_t^#J%uh#G|+iKPVcqjgbp* zA0F_)5&cR4`bzZ2rly>T#sZ9M{0nfe4dY)vPYYiW{hU?!1U+=+$}!>szDLDd~-DE5Y8^ zlb*q}hU`ndOLGQ=2wjTRHgm6;>*470A^MGej3f2D1Mu`uO+A;0RdXG`^S!vJ9`sdr z<2Saexu3^*(Z3__xRz^bP~`p?Je-vCAkLFX6ZJ>mXZk(TE8l0K?;!-RXU9A0{Vu#? z05T4nemTzZE!Sqa`=-}rJ6X;?sYlq712MfP zlES^u+umdzHZJ|uTk$KrSMUF_cmCl~7iog8PP&s0M2*s5#DGl<*kA|&qc%Up4n`+P z)Tlw?h$bNkCK@1;puuU94#Y7ynY}n<_HYCyI(Qd1k!5$8TV{+*RAw(cvbW4$b}zGo zbJ20{GBeB`?lL#*Y%uqEtE$uAM6vgey+7`GE)PxBTW{4{Z@u-_&u`UR?{bzQc6Pd( z^E;)w94DABe~))jq?6YuA99rbbc`bC0GbVEOOWQIzsLr4}E_j#pS>%@yF5u2m7U|cR^Ytw+anguA zqcHbVc0mtWckEh(ZLF_g3uYl_?EeF83c)UU34LRqm-Z#+EV6koR_SvVA3rMJ@w25Y z>+hwlfZz2r_Cw&2kDO!Vn=SjVCNAeRh%9#&TPwIH$2SoPr)|0AJH0~&9a07@Q#l{` zLQvXNh%v|B>y&w9?nlzjX~#iam)sXd2J91HAL9_b($DJfgv9?%y_ZY<)5mzILjTo{>CDDzExX z%7YCsU(45i#d!~C?bUgv5nk8)9%TXF{4sZs1%CYpN93N8E+6M0(5o=za_e(Ca_*LM zzw~dx=-49Vm3opk6nn>a@qAqmvQIHL**jGx0-JN1IdjBM+Jr)N^QYENePmbbu_@t} zjoSV|KkE_`5BX)Um40=YxpMH0TMOZ(n7+2e;?a|vYtccE=%AxLuphGcCo;zoJ*TcB zqDNBidM$b4v-Xt{BYTm>hP}vquhhL?#wQ>1py*x0PdEc`;a^t=i(Sq-h{~UJ-LYst z`$K70j<)tAIo}iOV>{(c5B6|&^8G%GwmZ>h%DEyb3v>B$`dA<3H8yokTQFm{i+ko3 zY8CSMXNjZxVf0GQEFlZAzmgmLaC|)SI$lrczOPTB9k z^~?B!f2l(s=pS!>SL7!BBjKx}?Ue90ZTKo=6n2YzyC zgS!2P*J5XY{u;fKy5ejM_jIRoSBdj?a(@Bd&PlkW)%|)i_MBb^cSz3WE_xYWSK)`( zMK9oY<4127J&Ip!!@~2T`{Zn~KP3AaE`7&j{}ZZ|zWq^jYQiqu+f&Yoo%m>cNY)Q> zUQ6bfa`s93a5>AhZv3KdtI{4gSD7Ve-{@z2tt(aThLdS4Xcy8>CgAYeOy8c}+yO=Z zT2A?Mh?};7F@I&Zj;H4M4ArGt}w3G6!=w z3(b9$ft;1;jAIe{+C!>T=0rjIKN%w^^AE)SpUj2j9J(X?H61?g4GboF#>Pi}pEmwo z%5YGnGxz5{#9wp&m;RNu%id8}%ljWU`4i!z{5tvGg^eh_H}sF66FxS4gLBz`#2(h4 z|GH_{BDqg(`+aP?N**hxvtP4FxoNvKB4-&Ve~3(F-7=~DzGiF>OB)U!yiwoRv2yNa zeG|PaU8CDBXA?yiMAzv5jEsRd9H#F<#`>)3T0ead`!U@63Ww5)OQs19o1CV-`NQ{` z`*6{AGIoPnCU;NKvk~|#*W)=nIr)_RLA@3c9T9zC-59oKCZ+#IC%Rb!7s9W;i_6%x zO6vsrC-u1RtmZX6@;JP{4?k;WYhF7u=z|Con`E8W>o{4!S=zRy*yBqWAG2|?q+LiH z;Sri<-Z4dIeg==Oo_FzvWD&+z$v56ruQFz&21g{18&ApJrN~6&J&Ye- zQX?73^f#0YT4`Hu zQU=*uCC^3nKAB&iN0+f(?u)<=b92tc{?(^aUlaQH1^I_LZ~7w_XHwV;V9n`{=I<{+ zCJFO=izD0%q^(JRCHCQ{$D`a|ZVLaM+4B%Nm8jo+wuimGJ!0qb4^*4XttC2U-V%1ISwHm9_P{ z@u3gx{3b)<+I|U|^M4~{WiHq4|Elo*6Q7)M<(o+xv}NAwq+KC*Od=bZ&pl6>z@K`Z z^Cp}Rv^+)aU>3C`yx+9kuji&J{Pgurg9+%Ke8>DI{VDn&>(g)F%ziU#B=*R#At`g# z@v|?(gV5D_i5vM4y~Ummx_naVFL+70TW_LnICBXfbz)DNws}PMk;Cbn1NkoZ4mb}W zdv4*m?6;*-*VwibnnDY@_2GiTV#W${x4_ze4ZoR|)5^I|!u?`{8MDqS)+exbEoa?B zUjWa+a8E$b0V2~W*VF3rcJxwXcJ!k8$vLqWIm2~uyh!$77#F$QCHGV2t=D(cCe=k& z1$&%6T|eBjK=$yPb)PP`?Ze+j=UVNz#^^qj+?k5rWBHM77oXd&p?#o>^JK`4E}XfbT*isP zwF_#3A#@Qv6rH4aHoi^v&`d(J$)X?t_pfwhz+r#rq(E4m*Eh zALND~J9yYAJS-P|3{jsW=!2r|%<&x&`+L#7j_{nBN1}Tj;Y(NR{k>gt#ATgMdGua~ z=zgSBbpNF2ywH_z@>1utt2EgsM^{c+9k}dXhxA91?w!}h4@;jE-FKC-TKXYb2kU-{ zc8eZ_!d<$*42J)dKIyL*Pd{DRwCjqynsy^c^38DE*%SNb=wZqheg$HOdENLwykXjV ziZ}N`xvRW4EmG`RC4FA_iN9|0&!w&hKJ|t8marQeF3s!qQ3lTSU|%DDzjvthdCL5) zQszD0!O$y|_gi{>lOcCBo3p;r)O`0ottZHpwbR_UB3GMrXXv1J|0B#*C4G3!OL}}3 z*+D0=m^|}ea&@%Np17+Vi4?nw9y!E59sDm3aegNAQ+qd8T<-S$f$Ex|eZu7*T!OBC zRqheb*|~&%O2!rX<8--S9UR~;?2F%{9CJUEa0w&c)w)lmo}&A>TEC{8!{OfQINx=O zm;W!uT6kKqRJq4)NZcNtJM)ON6DiLJ?`74KcIbn@(%&@nonpRa6ptUGTqjhU-oMqn zWqkN0yz%`n%3H>ce+_TaE`>MrOSR^@iws})9qD|4cDhZug*W(GB{+#I@xo86&EZ?1 zJKQWTeI{|xE%}yQ^1-{RSj&KNNtu|3x{z}Qb*#_-pj&NwsL$s0S|^&cY+38Hc-|Ko zQ{OinG`f}4Cv;bIQ}^GX?yzUe7*M#roIbghd(BI@+oibEoC5zp{QRBf72jviqx9jX zaKeK}Sa*%HAA6BGrq;d4@3}j*iF-z~6?+R}L!Wv6w~_M!-t<7fn-BM*<9|HU$}d%T zC{&(v!cR19WX-|ZD8d6RdymSv=Z8kN z+}mpXDr-Xao@Gt7Yg4hlH`6lx{U)KmVFvU1l=qv$U-^!2&wK2T{2}vxx%0b%dH;LF z&*YBIH~69*(qn1=`f}p;78ZxU!ud3JVw2d~(DlR|jJgO%zAF2bp_~>u1IJnoc*3Ta z>_G`m?p8tH*oBe%VqaxVn;>sla2E`o!tS8dxjysE-X49{c@-{L!F_M;b}+_uzD}Fx zUJK_W+~koJO(St6F83zRZWv_E@)zms&5zgby8C=_^RKYc(XCQfjEH=>C-WNX)}Q{9 z@Z6#0i!Jqa<8OV_)&u7?qI-qz&O((T`@f`fAKmryqYt*M{-H0_s!AfyBcqk%gPo7{ zA5sr{KDIVK{*E=&>{jr`#>W9{e0)u8e9YcLo%uJMc1KZqQd z`|r5Tutb5YV%`ScfEVi2l@UZ`*O`c|Fb5eC$6lVE6{IXsUPA8WG{B*OUwiQ zMCG*X9~C|GQ$}smaxfuF%G;yy2Y*3%u|=3ZTD&0z-c!U@9^)xI$XL7&Qz zThiIr{R8$N^JPzCGEzR~P!WkuvpC%j~A_yGB0w@LJ&dAHV^^p;+uGjbnz zLjwA}LS?Z&);zboI-*)$`bAUd&}SD~cKoafd3#&-Yq@1fIi-9$?kV&AB#LLwG%C8$ z{G6QQ-%tBVC>Qw~Iny^BXD?_r?S=eWW?+ZFwz=k0gT*a>I4J#4y3lU^Wz2SBOFH`a z@8RVY_Px=C4VjwP^p>YtKfkAKp{0?=+x+VHw2e~o%WnBrkF>w^N4m*}I&7Xx9d^n- z6?^8yUCH+@>h0W0`W%asZ|W2ELVHNfe_4Nf&1?BS>x@^s(IwXW+^H6OVZyuN*Oft? zo(a9IPPd$pI&r0j{*?Rr#7Ae2!%NyDwm!)_?UC21+cnSoI3wbf`jtMfP|bSB)^SM2 z2^qgy{_{WSepc$5dYv=5p0Cww=FlNmR3BsYEPD(uaXX`EIMi=E^jk)4)wY@BC zW>FUSj+KXdZwCe^`W$_i{3U4K1mEnnZD<$wLDTO{XWxnM9>~)lPWBxMd%0IG^sH>K zMV@Nwp{M200R72ltHKwtB_{3Umtr&iGgH?ePqdK>QrA&kqK!`0wcRFO6fe5Qc%t^t zR;5-E^ne%8+zlVg34jECvVmoQ$?|Hzv#xuzdd0h^9C{MmrvalCCZkK^U6DF>Jz z%lGxepPR??eLXsl58L_NiHh-lnYYQ<8=cop%;)5r2J2tubH#c-CpyPBj_}_wpZgv2 zxfypg?YYc+j(v&0WK7G;-5~R~AEe2BGi__;@qcWZcL#m>o4@pN&oOmRP_M=6mRyG} z?RTHqyIMUOnXBCXwG1pFSC`n;%0K8nuIF*Dn0cJGT}R*DGXDd|JkIy`5ng`PYup3w zc4>D)C%oo|dYqK~edyFLK8X7Vu436U)boAxk~L9#G%bCwd+=7~Y22YNR5O0EWM6Ea zrteA)MCWNUZxub4Fyd+Zd?A^qm60}K_EG5@W$iGSGW$6D0n6@aVg3_jzPOw7-XF{! z&^9-|PapF;cudeX6!aOF5B^4{AJDpSLN)1mnc?N`%k$!UGsep`W*z<|ytFpK$6kkh zxD;&AtY<#9L-DPE{Z@2AbS@gtIro}sOHP-QvPqd_4|m0T=&aaJd4)Z~Ze)FkE6@Lp z`o7}>TI`PdX~XRA?b>1IW7C;BFc{>E^Q?8V9bu3dan z3@d+eOJwxH7S{3HgYCE9vLfhHdbsLipV;;)spQ9-B4YPi#&lVG7OHDnkwF&mter3R zO~aW!i6`-+V?Xg8wekF7>nr?fG#<7CDuL}Bfp|-WSK+gzt61g%x%An`BrKf5w@>ys z!WqoTQjC2+X!4$1v8?q*bezYyZ?TE*4Bv8fi)>r|un-!q05rlfZi|kGZUF&vQt>nx2QzSaB#}s&xvnOUvboHsIeoI}#?+?C= zKRu6tw+&A-7Cgl~f_o$_uN&JU&EH@Q5Wbj4h)iT0m9nrW?ltf3jhDkG_n!3kQT?`F z6qYtTIDNKho6>L7R^@w#?xzo_LOFv=o$V5sG(p>M=eE@TOxtav-!6J&AU!CwTfUv( zYyR-hq%S{j&g*FT)YE?-mHzvO^vj>?zwJJZv+jiVLUq+bsgr1ZT&^y{nGKJ*tFI&$il%F!`zKnkGIQbm6{UCeQ<9$xv z3)Pj+g#X)cj_94K=c_)NtcO?X@7wt&#)aRbS~m_|Vjq6IU-pG%48x|1em5*ShRGhS z>_zB((Vd*@zY)C@+bM2b_OFSzO2z`*;GXv>?*UgZ_$K;6KS95=DmWl>{;Rb85x)Io z=<(u+s$<@u&qYb!C2{sp?>QM%a=*ww?G$q=|8nY`{gt4s{dR3){FgcP0loKP?Dsw| z_Iqay$+sMd7wl$#XMnMHMDo1y$H+Z(&v%qp=t8fKcA6!+5~t6mdW+5@iaU)Rh2o#^S?)Pv})>=j18|2Xr>=Y27F&)T(` zGb8Y?zss}krf$zl8Khkc{~}u{%ewKd`4i;;_xW=C?hf>zdnGbli3~+=(Yv7^@y%pq zIc*`4HXOB;`JT32JhD853?k@x#J=yijyVFh2G_6U>|gYK$LaK^ztr|GJN5gGyl*7y zBzeC_>{~~?(K&|tqW2SHZ#uqEE@NLV`j@_*dG31Vx#5&t$9sDCC*IS`(l&~D%Tb@% zkTWiFHcZaAu-+9L*Bvh(f^WXtNx4`TQFq9Wxv_oMF;BmzNZF(FyAsBC+J?3_wCm06 zBhr8Bwy|)LkG2t!w~MgtfO{>?-QBARPo+WMiyFnGmXf}(JS z{uZ<>oN?a~IctFY%sq~SiTd2pp7%Wc|AzTWpM1G|Q}kN1_ni>qQMv9HF7rJ#$E_6S_WI>6oAeX1-jzN=*1KY_NBYO` z_w^jXJ>Ko@q@OGwA4u!m^~l3bd)`m#U|n;35BiQO z^xencIRMWA!?Ws#XL)l6o|8YlJkQ?mU!La|-kRWXmz)7 z_A3LjZyX$uJ~Md>XBh(fGO6c3r|)O%26pe+#rU{}ar{;0WxOe3?C|dSOKj^-vBP_K zA?F{wvM&GNiQ{nRu~dFE-=(HXCSueQgfwkBl+@Xs6KCzrL7A2}xweJ6$Q1V4`Y^&NqCnUjqOFaPdQnHxfD!af$~7G3k41c^s^pkjAacMK%(q=e!7h7-8KD4dQ`ql|soies^|Kf~pE9i0f4{sFN z=r?r2f3D9&bcTm-Y1+d*lRbCox7qc&=z~kLkCG(k50#9;qEp!5_VIJPsk7&CeU_3r z_`YV*r`;Yqw@~|7)2@^=qHZcXfP`7qXZ-_u#z7h@4xHwx!QvykgFbFyB=4CEa{WXcd{sSu>IS zzQ^bbUX}jAvsU^BIajfd`55mErSg;ahUg!5=aa_t4|j-cBEOt~4~lHM{!*WJamUU> z?0cIxUu-`?{2xfaC_1G3M&Z$(ucXM6{-X1zT{Q{+;f|-NFXFxM4e#0Ln`M{555&PA zj)QNHgRhH&FOGxHi-S-9a(wbw9Q;Te{K+`@o;di9IQaTF_>wsIU>tl#9K8B+e9|Xz z@Pl#ieR1%eaqx|C@TGC^tK#7Oaq#Xh$9qQO;7`ZFAB}_Wii2;8gWnhjABuy|ii7ul zIo^FP4*pCW{INLr{c-T&IQa57_<|_@&fk9Ji0}E23h&BgjH2hg^P=f~FBd+kbC&p* zNgt&bjejThx#jOi){TcZv7tXDUA*upeySU#6EA#fyeJ&eZ3tE{Q6e7bVmj;)OiEBudCY_F}@R9Eev-{7xp@NeDL=-<&$UFEOc>aWgS-L}>LT=n*9 z|7Jv6Me4PU)!Qo?YoD$5uPJ#b|9*&XCt{<-+foe=mHzopicD*_K3l!LafSb(>dh6E zjoY@@K2ItlZQfq}%#P}NDGaOAXgE&WJH;9doJwfEv{{Lf4}txvU#8F>1rz|2rBpDiOMeGBO&-e(TDRM}o#OVY9i-bkZ0KwY^r;<92A)m) zZ2|CPU?=z(aj+XZsH96mU(#OivtLiTRJNT|YZ(zeW$G?%6l(T-=y8R~K z`X1sr@~!VSa5Ud~_@0ChPr)|=JLONv3BD+&=BvoMxyIdg*1G74 zwDYYeNjGTpp}M$FZ5=RhR+CcI#Y%0Z9HNI?I|v_e#1sC3v*4?`xL0jy13nYOZ;2Q< z3s>lDp*+IR7WmX|fuZ~KfywEf-ak3r)8s4hpGH2~EjQ_&l6rCQ{nU8_NBMrL)5L$u z=KGXRr_@u~Hr!|Qq~@4)$w%68joZ+F@(lDG<$dzBflYapda}sSc`{_(ER$~Y*yMDZ zh0h5&DYf~iiNE=GhLsmJZa)DAiv6D zezts-VZ(o=EnlTF@TPOdt?0IHqjfi$a#s{s*l*obLp+1ulYH(=mf;7iBr zH}p#_zomyQ95(KTG2=dR!MbOxTW9!tL>ahbzjZCYCD{gkxJ%q#^>91<)fqk>?Cw(! zw;6c(X{8?Q244kV`yKdl1K&=0H9lhsKHZ5|>LJQ3diPL(@a`C$hq4SDgioRKkbg3r zhkTRiJZQ`LAbd%EJ=kIBJ}CTj8oCb*_o)X<4ZQrgQV$Fh54sY+7{7Lrr|?ru`n~P3 zbj3{uUJhQ;6=$3H4-|>ptL{GwzRAS@N_L;R|FnVEfd2|{??;Y0USvwVMrSUs-BT*Q-QXcSY3WP53MuT5dA~5mOfSr7#8aT?weHRTM_nkC!6n{eJzJ3E6y1nW? zk-vk^eg4UGiq0E4MIx7pc)hAf$}_=#pDL<%rUR}sc#{vN^wAHIOOek>hj?CRI(BSB zCf>SLljE%uy&->7zFu|jD6k{{dp|L7G{1WX44r%XCeyjM$4N)2dy%W~b#LjEc*uQH zer{lAe#kRcKfP-0h%-I#*~#(OqDwJ)eQNE{l=O$4>A@dx#)lsD?#zE}(UkO7j`K_;F>7hr|yP7!LNfK$>;842EVRRVB(hp zJLyw@0vkTSOS^F5MGg~qj?u%9l&7F?a=Zf33unCjHeM;=6a4n6f)WE8{(9A2!k;6* zyN*t#b63RBS!2T$e^RbBlk)3TYsk+@XHBP*4)``;2On#~29ENvrqG$5_ytqqhYa4x ziTqbN({p-a)bN>q#!077nR zGQB(No%H(DopsLi?9M??+Si?K(;io!GjdqjNxWjy9&Rh_Q!6_R{IFN4+X{QtiVKtR zE6z{B7f!(!OvW!4z8v(I3tzxd`oW>e_~4l-_`no=mJ_ek?HQ(Ax5KZL@3xE9{lvJp z!mrHNZtb&fmv!Mw#^YOap;u_ipLf1b-I{ISl2Xh@k~Z(CiGRyEq1UT!ISoE!;^%hu zsapmOEc2z@PVfW3K?lCyz@wAgI`Ae5^ovpM%<<6 z#qCu~PfpH%spJPg(fpSlpPc{FW0Uh=3Llyt`l?;>k$jhitV{WIxZC8Hdy(|HvGU|z zFmP$NDNpW*iJwb3gw7Hx_a$dc_>v~;YP!8@Njm8RhTh_yKDESW;Kw3LE$#uI3hZ~_ zp)2rX&{+)cIb()i&PMA(Px8&N`7bV&@LshTx$R9ibOJ~F)Z(Cl%WIShPzQ_2SIU{K z<%&CG;VSDE8TaM`hW^a~fqT`WvyJ!U+{InUI!k21TKef z;cJmC*P>#R|Dur17x_8Mvnb2JraaK~PQk0m_=OjM9egdM+yY1WS~v>q;AJZ;^6>smPl#*CZ-luzm-KzX!_oW;GVz_<(gOu7Y~)(wl>tL6jmRYopZ%p2#o z8Mumi$zuLFAN^>*=)jXs;41jZ%H~ITgufdtpEs^DbTiKo@4QJjH`u2#i7)U|$Ca8J z>{Xd3fkz$q0RumERPah=9sM5k&Bof5-eCNzc5dEm9{Gjj36kHCH# zenY>3Z)h{_+_U2Ls<|g)`+!oOxx|xw!L3b(-??2TUPd|jkC<}J-rvX5bq3yAsMPHJ zy(*&^c-Vn2GVs=r;Cb3FVDi1b!@3)dI~)F_K4(Kuy9L(GGWhG@L&C2ke<{y(UgM@; zu*E-PfuBiL>e^!plf*V&HsNO+@iGkj4DPkZphG_GgE9QI zV+MZ4XXwl#AK_r*p_4E$W4QZt}2^RUT(<^jU3e(HG0 zNZ{w(5)V3Ud*FiFf5E zhTfHD3GX!Vu8j1lE0Kr5;WXmF%auoMydJ`99PthtSoX^$-W9-7&eSv3EwOHvai?2( zOmDL=Ws~wuFNIFX&`p8H^dbrGQ`1Q&;d1Imhbt3*+6BUGy`&uOQ`62FII_{in+89^ z$27NbQ?%SLXEtEcd&0H-sl3?p6q0itG+O1n>-D2aqx~z+QgszM7YZv~t zn`&HT=_<-2;i}uZy8OVU7Df&t4-a%Y`b;_6Ymh(u3hWkn)_^Bohn0If^HWc@f!*cc znV))mz=v)60C@NiSmfOvK;9RCZN0R6k@q$>>;d0lV9Dpj9`KF8wjN(>2VZAkj~9G9_!8g_n|}@X zA_IG}z}JA!1Ge@2Vj=i!1A9W?3&Hz<+idy(_*4UXHi8eJCl`RNzP;$}Q;FvcEPDQ; z7yJ-#*rfmZDEQL`_H-%r^-=K0fSW9S5PYA3Jx9S0f+t=_qs8}t?=Y|jI$!Sr-w0f9 z@$KO24D3NqzTOVL1laBae!T{Kk%5!k;A_C=0oT~{h2XOdoa6^z2;K)=W$^*=p@$KO244gCwz8!oCaFNB=fG;v|(kI|+z~=!MT6`h+ zYy&6LlwK$V?*lHd_yG7+11D#I5A-V61>lgyd;65@oPm>r;Jx67fL9rO+bH^DMpxe20OPaoc*pHv;Ecd^`9$11I-@ZwF649oZIN z1HQ<>$tS_rfX@RCSbQP)Yy&5cfG-5^1J1Je0Qgh`Cy#*-^eS}$*l+RPKBdkX*qaXC z3w{VV!{GOff;Mwz&8S?S$sQq z!UguWgKr040-S2`HQ^%&=27Df{*WwGoXB*f%0KO2s57=$-0r05?_MQbFKuM7E z7I;(EvTmVu3#=Qm?kejBt(#}vT-w#mVcm4=`mCE~-Bjy(t?Ra~ zvhL$}D4UWG9{K#%@LSLCL4K4~J;bk?-zI*PO;z%%<@YGRwfyeq_ar~ct2XmPUg}v(#MWf@`(wB6EamjX&=b{7uIHU?=`x8GqSP{B_3vzyR}-Ta15Jgz%v8-$vaf z?lu11$kBDg_-~@F6TQY?86rHx_-9e)2_GAOSr*~hHoTGWdyW4#^v+dc{MU9XjyoB@ zjF0Me<9A;m&fgk;AeXeA#{UR)mGF()h0p3UrBk@ z-xz-ya!@Yg$H!9xHcl#jE30ct$?JU+{zN*_|DEyk016X%G)kOt z6JFkf-`3+--1r|g;dh*czLnKYlJ5!=KC1(Nq48e}Z;8LADd^UK|93IJr^w;o6Z5-& z6Z3mskNFdi;kSRD)v<85GwqpJxM#@WpXTsykNMqy;PC%`76_>JGWO?EA87-y=7Z{ zqw#OuwpGq%HmI`Nt(AhU+*ViCP+w6=TpO}|+jG$np+kha>a9;U)))d{E4OVSfh7of z61?^KvK?FHw5y5kI2UUIs+;O7wpNjf)2k+=p}MgQs#_}R4g4f4r*<_q&t1Bt+ z77m{_kc&Wu-wEM3B~wvfU%j)!RBo^4EUED~)YL+H+jEv#O1HhbzD~tqWCIJG*7Q>y3l@r0J)gS<@6286a{q`J|vXb_T1G32+^JsV}Uy3q*I zoL_dbA$0+zwH!Kb%2#Fe+qYGfHRUgx@F6%&$OLYxMRMDsWXZLbden*~hj9%%BIkzs zZ4EYWPUBY8JrolY)i_ZQIqKY`k2Ra5AflSM*|KkPx8<&?GR4qb=1W~q;s-sOAdP=Q zK%D!165X);N$ZFy^tP(n%{!d}5qXQQ>C~vu=cQTQL=h_+H9?~gj`USK>#E8c8h30e z+ayPiw?0``Q(adtdZ_c>WslboU!!Rtn%bwwc4Dry_b>T91Z+p?_+8J3kj zSy@^3j8=W?hdtD_fyUibOY4wUP1>m9ZkL19C87c5c(p{$=K%Gy)kU>ipH{R)@Q-k$ zdK*lkvfHHMpjKJaQ2QheMHI7Qdt)(YrG@PV@DJUcU$kbY=A5o(i&g+poFc@Hev5az zK88JU_?mPCA|;MwtFoGUp;AqSHB?sARaZ&3q{`?+wpVP@*$agS?$Pl@ximpKsjU@T zfGX8v>LF#rGcBF?8jS{++ zye3+&8yKhYw?S}wbzOBuLv>V8!jh=Qrkz@8ZL<3wUGu;L@Kuk%YAfo>HbL>}ySLIy zQBF-AJ~TN~<56mp;y*0nHYM3q(NNp)z&)D%%KDws+26Qy$+BF3>~HDPyjz#va?9=5Gni=fqXA2_Zj^#4IbLavQ~G{>sWq?k+8fLQ(hTPLp0G zaKrf|`TQ!Pm=@W;GIYMOVds`jbeS}trJtv9b2nE{`7LH1Ci$-OLBj_P=6CwfUslGc zew3#iG16J7evDZPxvkgj~w)5W6vTKv)R1Nqr;my z?D7WojShP9pyMr6OMgRQBl_O+d%vtMX8kUP%EuT$HYnd|mSnXr#H08gJt z9f%F2LbYUz&9AF16vBYy1udH#yc_}ViSE#*^R z1vFl{JdK+UY8rQX1JFp2w|J$Wquu&1{pdUg97>Dr`vCfVp#2%TjiejgQ)%N7vDJl4 zc_+%+YRDZ^)6z~IGCZGpJ-2O4l?Sl*zIBYgd(1z5>+s4+?X3RG>KnU6+HShO>pwct z$8^&#_@yp&8^M-AWRLV0NhQeSH@KzPGbj-GwDWeCjw3c#ky$X}rj0MqwkIiLHt&fA zz`H^x5?0x`3HZ%>D#+Bn{gu_aOWTalcCSMR6MXHDt4+(F9v^R?qiV#SUF+(^A?z)r z&I@4!V4BOfpYU)}VpGfBwBnaZOI{}6bXs z`0|eR13y2%COp8~+(7PgyH1ZzECuvFnizo(?0* z!~EX}58yK-E@exP@`FEBXzmvt{~~F%r1P_l6&_gXbEN;KmZ`|*kSY*5*qLxiT%pH% z5uwN>RfXKVVt=A_byCTCZ}MlFU+{(MCSyC7z7L*jB%R1Wr<0Q{!%ye~0`+9kGQr^o?Bn3O?DB7;)EcRjo z_Yk)P*6 zOmA;Awu26NMzC3vs^9-P=oz42%HHs{9S6{H(HF4;iLJeFR|ufa9hX_^mh`*Oh# zsHfug47Ew??+NB^$Vu#{6so`+c_Wcg(%+OcG;|FV`?uwz8>#RG*eSfTcH{Bt2 zc})3SrQ}uTsMqiZW7IigZlPK@Q|d(YBmab}QQlsT$zuMaW2?Q3L|3qdS~?*|?7>XP zI|1F0af~)jKawZ9Avlp+v@UovW2qgZh9+p7pkJhak-7+W%Ns12dVYdFWKE>cG<7)^ zlJPC;HD}O`35A&&=d&yXsz*x9R^Z^-)K7_PBd>4IS?78&a`1&w@u6WV-OBY3d zrs_lXr9Zkjp%0=fF`d}(4`b-^_{hKH{A`SIW3SA$T%Bg@^IO|-iauG!!Ug&8RVp^0 zI&o!OEL46ye}qSg1H51kaW>jG8?A06BLD7F{i^sBHigHoC}$o(zaVqUgQ{KlAx%M4 zf5X=^x8Z$WN1U`E{p$XWss{ONByPyWnM6n8xNMxD*x=IkjP#l*>&;a^VqDma&7U{2 z%k?@dq7vctLCITWE-qzf+*T#+x%lb_NzsX+7=aWpNvySx@?R! zvi>mhV8#!5-&@av89zQ~9Uu9?+M06Ci+_|qKKw;%3K_>(Q$%FVA~vRi5yrbjl_jh2 z!P%a(QTw68b7d@>_i5`Bw1<~;J5EE#U91V=DY0Mly|o$pQ^4R8TUWT#*KcCXna%s9 zAJgY|mlk7ZDi?WYN1nHH66|O3&e?Z2bPdYP?(CISe zBbBzJN?Na^6Il|sGN1XeiOU%M8GSkNTj#Q-9gz8oe+z5B4Ays5TBq?x=IS<{NFKaJ z;p8ndN8C!eu(oF%f1d?$HG z_=B=0ZnZ`N^-3f_z(bHw%_^GsI+esoymgi8AW`4y_`w*+5P!Ld8NS(GJT_eqjB zW2^38c_-0^4UB)J7KvZz!rvfu>zB6+MYkvOneorI--_t^j);A+jK8;GSxz1XR|^mR zg^byq!>eUpg#4cOtP;I3_PXc(CW^Cs=()kE-Sfp}JAFXnc6rBocrG@0b=&%#m6fV< z#&pYsDN>qfDGM;}@zcIHfdUw2T-Mp&tY(FVV%Va9}sdLCDc zq-|kmRWR1X3S4d5qXCWdPZ3v+hw!zqRgMIrZIbCS9W+2CQctH2U)4n>BcX0NTza9^erGCQZyt%I-yFA^0y`y~aS_&MzIU=&-oe(J>e%hhC zP+b>&dx^G`cuA*WP3@4wIU|R;Z_$r>q#n)t-AUd(C)mq62u*az(sV;JLG;tK3)VBy zI0sdpjgvy0X~eN_PkH(s;ga?RoAxj|abEa==PVtkRTa_pHNNwC9i9qL3G!B`;CWZa z>W3=g?IFES32(+WGik|}erJ~MUvzrpr^`cJ>L-JI(xI0q^dvoDUUA{$oaIBmy$H>c zC_j3A`mQQOj(YxO`O0JOL*DRmbv~xYH<{05w4?u;4(&?ko1xONgE$c7RrdSBp>&z| zXQ1E3V%ssCz+27{E;PN9c!0Q_*i`O}=5 z(QrN9u6#W+n=L$5w%PMs%fsK}wDAn-?*x___J zv#%N$Oqi$FL_d31m0yZ@J1@P(US7hyAn%Tsx4Kl-Sh=_JXIxH_aeya+vs&j7p0BEO z8)H2ad?PbzKRoeea4&=VX{%!0{rj}B&?srtva!g;&YyiG>rta-UZO z9PRT$ChoO+txn|%yecAZzxsCAunZF?{S6DJTKM}>U823Eo3N`Z#D#a}HolqC)&=go zPWp_it0g^k@ri_69jt$auGa+!AoKhA8A>N|eymAf5%eP(AXV{dDw za+9~`Wf!_QPgM<~ll04P2`%#0b)L^Yo$$f@<0w3d{rS_fe$ne0<^$0+jKr5YL)6vZ z=JJWhw>i5v)-CgcJ(YSKFK7|jQGVHT-q-9YpbUD?mOh!W3R}~J6DI3>w}i1btKV5C z%)4(BG*}-;So0UEneVX2SgPgE_%7k{Hjx8=khH9!$H%2F!)9`+tnt9xJ?5FaNWamM zzLfL}9r(vd&-!{I{YIUhepB|0SMDbK0A)Co6o5`@%Ubqx4xyvX^n;WUe*N;c25=E^ zqG9Z@T=ipMbk}{3x;ekge~rvBtS(;tORIP2*-Y~`#as_#k790;RJ>s=;|1>=3QzJj z5&NxXUyS(zJji~C%rofU>{{t=*(Xb5f0#9IbPt$!>}7A2`d2L)f7NfnRfrrUZL8fA zbgp+DJS`+2y`Cd(8tKYyx;$)AhitiNb60+(`|mmI`R?MohLMMapR(ZvgjYGj|HOt@ znQyOGzJ}iEeOa;P`?lzl{SJp+=HYNiEnwcMzg_BiDQ|kod^G%@n0unD;h*0k-{T_k zy-4g2hh9hj?(%3m;n_}(>jPyd7t z5Qc8~-ZJ{6!%FkN<*K2*r0ep(lfanaD&4S~H#V+kKKEW>PRk+m{2fgB}rH{@xWX|BSaqW;cb)(?w6D4t=-@xTUQt-7`BfY>+2&xYHt zpO}mKWt?pOA8#{Gru$ox-`DoQrGG-^*F~XPo zI_;G+rEN<)OE z`K}wkRPNBTc88uFhZcR!Rc}$ZTEFafbf{;Xrhj=_sp+6ekM9K3$~_o6$j?_JEd!?dw_JKvN(jdg%K zQqMjPYl1BDaZw(zapUHl#O+RZD>HUO>&PBtD95gpNXjWO8ccW)#ElvY$l5#PZ z4l$Q57|fS(_KFHg5B|I@Cp53PFSf3hwXCeG*{gfqv{kdNR%y<4wWM8HF8V#~Q_AlZ zzbT7-d*_gm&txOPp=#sFAruorp!1z&gsh# z-+_L*Nv{_oGEVAoim_;7oT`Y8Q}*mxbbWA?Ga#v)HS^kc-$I-vEC^b-rs(0{6cijIdR^Qadc&b?>*r4d9Uv!4)3XSd(nj;eB4)3 z&3+^M-?onCFxKgPq&)_|SmUWvv*(+9N%$a6DSfA|SNcr*9^7x|NSl!Ulf6Zm|Ld`z z@!`kp$BIrDOF4tBypJMp;=QXv>&Aa|pYEqma1Mg}BoFdX1HMH*P8Ay+it-7HM+_SO*_a)AJ9pt~;QT zaDBMRxTz~CBl&r8Wv|J(XPFKhUB5^7dt|*?FMHv-4&;odo%cu2km+|vcxyz@_s_D& zEc5*znlqp1sw=X`QzhTbBH!bj*rk-bT3$(4_B|u!8LkXzYs|%X_tO&*evE#3B8(&XRnmHlX37paqt~+@bz)< zC2{bc=hG@X`jTw55~dw#ld&R!8gXim&U=bii7vZ!Mnd4pE4Q;e>x8SXdHZ3 z9DGw8{Kh!=P#k<#9K83-@!oTB@Mq%SkHx|7kAn}#!I#Iu7sSB_;^0%i9G`qX4t^*O z{&*bxfjIa`9DG$Ad|@1Xb{u@#m*bNz#K8~8!S~0(cgMlE#lhFa!578B=f=VNz8vql z7zckg4t^jG{%{<8dlWxqx^mgKfTHp4{O4EXk6lRf7kz8za&Pe5IWjq3=+VjW)O4F` z>*_Xfr<8li4P|TAtnjbhD$nuMHZ*bp*ROA*F1GL1Y?7Oh4ZJ+FomY6KK~}C6Z{^md zPFKK7k&yNRxYUFJmzdZWWSpDQq zKNNM6oM}RKGTn!{vszc(?A|m(w5^o@nq#Z#DYoFAe4_UG}8EVly}3fO2zkH~Zx_T(*Dya`8*S z8vKDLE9&KCoXzv+FVwtoRZz+8M_tV7XRGV{^KY&4KTuo(joTXhT2xWulAwM^LyeZt zdU^0@dv(>0O5DnA4UJNY&Absbzlv1meWV7SL#pyO);?K-^aWu=E_BST;-X@C!AEXF zbK?$bbrnrevlWA!>kLQoFwmql`p%>z(NRr8^Zw6`<`_zYa7_ZQAK?tf`i#owh4mO^vl%su%MhlakAon!eV9Ez#$P zo~xiv8n+H$g|rcN4o~ zd4r~W^RoKXP3;Dr0iAiIxhZ1f*Vy>*7fg4=FE#M23lblCxuietz(Yge8Sta=8NdS$ ze7b>W9I*JbDe2)imL7hT;b*~l>*{j%ss%mp;fv8-0RIBdBA%3ELAT+50p+`W*b%SF zz_XyE<5515*MdCj!jH&lftPrFj&$%L@GR&_x#o`nACBSYBVU1MMJygZZr|^~pEK~R zMw9RS(!fv$S{J^hKC&X#B|oW;EXr})*%;j{=n6dZxS^Y+=@Bo3a7Vpm!MDIODZk{O zrR&#W>-e~ZnSQ>b!|R#MhrX$dcwz?GvG_RR{j}17Ot{xsdWpii%fLz>|-_naFuY6SkXeIcFa?`OXeox6Zm&KC^9k zXRos1w%oI!C;VS`&bpsi*UI_20|rh%Z{4%vVx##ecKG{ae5E5NfinvX-|21in@1gZ z>Pz5xL5r^k?s4F23_LH_lq=oxonCD7Bi*e|dU*yG8{8ttbjow9?f*p1>Bv>!Ou|J@ z*A5&0uRUqqbmPt%vo8FJ9A;%0SNaEmXX^6e_FMR{btBd-5f_`$MdVi%E6+^iAn-io zD*4ZZ4^2-Q*Jt_hby(Qa^Fc@G`6PX6jGk|mf#-D@dNXYLYer4GxMsxAx#o;Xf6XBB zwEg{+!`PlaX5je)*mNGoHZ|p#gzt9ZF(*Pk!tXV0)}?+lTx#j(5x>*$r|DB~0?$7# z^hxJ6@vpXgU2WxeHTepit2?dRWawQ@xt;W`E_BlCRaYaAyzW?jSBDHdpK?lmSHq8{ zn{M2+G3$;R`e~;pr%yZSOpi@%_;bo5?YM!X@=EIgc9b`bayZMIhWsS|G%Gi;(Jl3u zmOUk1)|7P0q`PX!x(BRVW!*I6UP<|+f4$+x`K29XP5Iish)WI zO}Z=G#!bCo-4W}a5w};RN;&FdbW$mYz_1M+@HN18Jdk`+;Y;9bugNDh*U~}mlj5aK zjyL_Hi8uWm;gMK=)2SbUvxzT!PyfX5H+|5$$85TuDd~hyXSyyM9~x4w=`~a0mpkKw zF9LRyYkGl!qve_&u=G-mJ5BS|tEL^FoNn4tXFBlk;gsjJP6J2fIjwX``Vwb)Y@6pA z{-bqBY$0p;w)N2e6Z|4m??@{Y&`Sq$~iC1IFD$?z+1PQOx~KFs96r?j7B z%U5!Vg^_~}w{()uO{SCd$z(c7XC!{FN;*Cz-m%H?Jn$oQJtNlD`D25;ig@LQ&&0FX zAQ!y>&TZpr1hN(T??T@#awv|)b5m}Ca~n-Ox2_MR+ygeg@Z*e6nJ2|RY~x9Or4G6q z4V)Vmy2i%%Bs#@TI@r)Y30!E?AIF9^`3o%X)g&GVPdV~J2A|Ld9=ZZA?I-^>@bEtg zU+=_2BU||7cfs(RfZUw%6V6PIFE+PzeE1Ys>{4lW*t!<)ft>0Io)T~QQB%%5Y$Q883msQZ08%d41&)#u;(oJLGV7{ZkxUbe5!#(?{4X#JzM}jVDas=hjRu_ zBHb*i!?=2k! zPrd>t9{@iH-UnQ6)AxW+HE=R|ytIdY<^u3Wi*Ki&IcH$0_oeONahKbEU}+8b(*{mH z555NcG2jxLz7Tw$fkn@j7J}~rw*Af00Qe3AdjsGD;2VL9Y*h{<29R%+KreBf2+#c|$2KMe3n11X6@G6UM=dFWt z2KF8U-wu8VIB4-T;7=RaOMj4C1D<%x^DMp)e4l~6(8((L?#SendHgL*D@Ppuez!^s^U$Gc3NHe)yb$#U}KUcJM>M=@wrD{1K>LhEc1jV0q~8$sTS`AUuR%>TV;tCdmz5-_BbH=L|fZ zd>6Na9|9h>_!{u14LrRbd=2a2)@t2(>uTyg6{%8WAOp-gbO^q2Ydj0Bk*a9 z_kyo8@br`5z2HlL2Ms=Z6nv3^r;jL=JqkV#_@u=Tg3mVa^fB;*;C;XY7T*It)xfFg z;Cp(Nx&Yj7@$G#|oilJMbhF#R4*?&y_!{u14V+pGz6Sg;;A0kF2%dier`CZl1m6XG z)ZzmmI}DuK4n6?B5xCFdz2HeFu&jr&z2HlLdkp^OQSe0uP90F{=27r@z=th<5PY_Q zQ_q4Q1n&dxw)h_KsRmBH2%b7{rD58ivWQ%?>$NWJPs8Y$xC(h{mvq{_VBPc9J!jof z>!QCp9`&SM_|fjLb%(5b#=57iJ7`_%U&p7M+U>XQaqAwl?osRZS(h^D_{dMY-PS!| z-Tl_>vTmn!JFMGo-8Sn+tQ)p&lXV-dTW{Su>(*Ge%DUy&-DurX>y}uz*t$j5EwpZd zbwk!&W!<24^Q@a|-E8Xytea(BzjZULn{Hj7bC)aD_bLm=s$W(t=L52!>D?dNvrb7Hm`B7);4u1FXo6qn6%jEMialYrU z$-Ft>Ek{<}#y>;+`>Y?`Q`Z^4OX@Sz_!C688jSzSLHza&3YXN$!zSF*jsJx4Uw;7q z_pQGR|6A7Ifq%L2CmzMW#Q0^*RexdpbH?!BW8<90{|n;})Z_oD@!!;s|F4XHo)5o$ zPeb0nRBa}F2JOZbbnzcy{JE23{zS)H2MOPdg(ut>^CxCH{Fo@1pmRLtPq;becO7;3 z2V#DAZ_J?+Mg%vZ)b+|4(6Y9~=CtjKegT z>*wf>G5KEKP`#sSn|%afbKN$v%I~zD@34|@?ABWo`jyqSyaF)wu?vT-d=UnvYAD;Z zi6b?t?BNF<)`YiIY=62M3-tp3ANJlqKC0u&6Rp+{Xs`qgG|+%dT3CVx1PEK$EhKQa zezr^_3DGjLgDnXpEM5f2AYzfUqz2?S@MuNJ93J1c*rRth^?> z$;j6Geyi$s-xk8{`RsfDtv)n$Pn}bz&N+4J$Gx|1or8M` zF*X6@IbaH7P`y*1U(a*zQM_82T~y2H4!i32n~u}Rq5C^_=x7BbR~o4T+!v;*V!VR- zJv&fx->&NBLrt&*N~xVgiUNDbv_KS3+0EFzBqJ0Uj-y>n)f1_Kre;ScT_Ep-M>ei4$7_KEF5TRp-0d!VOh4S$+Egd86p5S zP+=-)VH#v7Ho?h28HkmDP!QNW1;ypwLwN9B-JWuz9hx47M}P$F2zP~-pqY1p3%yoL z%~~L&+PH>2g0f0w8*cei_Td)D=KTkEA}&cd3<5<%sE6i**cyq``{4uzO&vmZKvumi z%j_2POu7SF2V3@<52==ef+}`{3I=k3#+ewJLAm2j!)EXW1~{m0+Sg<#LV4g4`wvoy zh%g80v3nC;2enme!6rwdk8y~A%_hcLsir+^o6!icowk>9M(J1B^~V7WwW{$%d$6*c zVK3TPszuT$3L}Pw?2(Muu=YV`p`In`-)f#yAbWQB_{V2~l$$?=T+4Cz;`jV#jIV65Z;= z?E+*Fi3mAx72+m<2i9Kl?=!?{*y03b1D26zk;cnX>c6lcvEwvs>BRfNzs1tmiK5UY z{1?8iMsS-0;cPKUoCaw_-lOm@Tn^WfX)tE2ho{`sAKb4f9xrh{>cx+3!xZ)IMfesO z`{Ew)BA(6#8SGaBTSmz-1@IC4_(%C1Li|+{((OXLieEw_uJ6OI96$aU{xA#Ipq2M$ z%%9}1XAGGg6A_)zBq*jfuL(i;$A2T+3A(riZ@EkG z?K;ki50>DJt4KK~%b`5a{76P>%M;^QQHBrP?b%Cs&MeL}0487J)vWEWQ304ybYZB&F@itV$=IN z-!Aj{jc@w9$lv@X?MIvU!sFfeHnICj^(}3P-|$kF$-W=`63*`9c`;|zc`=j==O@bZ z#)sp|>~7exvc}lyWDdP&~@Pk34*r;>6WC7VtQ;Rl`?pYMsjKOGOtypk zF1AL-r8v#@37$ZkB*xR0UqhMl%zT_76t}>}xEm}#iJh()=RERUPs#6)<=w=7K? z$B0t)v%klAyq2?wfpA&nZ@$g*PH|3zJ_mF27-4)PJeX4>X69JL`bRO^zxTfA=DCJB zU&dLmxISzVJ?-&7YH@$PG|*m;b5`CP|1)g59N)wy(Puoz;;j-N5;#A=|02J^^}arS z4nAzj`H}SVRq%T&uH$l!jo-$1x3p`D{C1Y#w;tztG@G7i?;AxM#ht^sqQ;o8(tBb2 zI{Xl4;ErE~O&hd+3Gz%P9HJUb#*!{1WeapAt2-3uJfmA?MUZul6^Dd!l4@@w55;dJAB@m>pF zx_bG&y5*eKGfB2r_}tP`yKFC<$^P$buRr-j!6DgRI3pi2R7KkBvG=3e>kU(Ty@B@X zLwmueWqYB&$Zy+^vAs&(Z11~;_Oc}5tf^S-l|s4o`OqG;|K06{zIs=C$uo=dd7hmNLz`P=(fTc#F)GOeQhN&CuyryXs7jTFYt4sy|MwL z&2Z)k{G|PXcX`Hcl27EliN1VA_y21=lkKj4%ySHI<`l;}_F;^5ryuTbtMttr2G@U^_Sy~dHhP?*prKK@Sd!b&ygTwrjj!f9xCf%9tJIQzi1<~aJ! zad8uN&ct|iV>QMIDKF#>_T#+qlYfnK2@B+TIJ(Rb&SyCnO2N6FJLBxkL)pRAnBQJV z!}x?VirB~8c_l;0SLdwcm0aq?eBU0D=kK~aF=#NRRk5wyt(Y%5N`~F9v5q312gLJH zGDD~{h-c6N@ze$G|=&^GM7B_B!u%GPx{bSg_}8#V*I;K8|37D zeA=)DBi@U=IzbQ%#9$IvWyl`GycMfP# z4(B2ybm_H&HMk&NpSj`9K8iCQc-9opG&p)Z{u+Fy9y~1Mc`emqV|;R;^ z7w|{+r4HW!=Nya~koVDbD0lU6Tl^KCQ^PaMf?pXC-VWGW#vU5cv4^;Rv)nP^ZCx0L zl}zI|<-CKff8Ji2436b2IzoEr$5KG*^@^8AX9U&7Y;7%OphOlYK>dGOJ1w)=4|Q;F(hJge9( z+r8ikqmFQSoD%{YT~y@}b3~PY)+nD-EBe?^<$1?A*9E-iO4;H@rEF+-<>RmWu7QX0 z@z;IVY47%DFpqcmMx>1|(r-8XOxaa*z%C&vO9(cCZ%SR1EbF3W$^Vrhiy?>7CI74U zkmHs~j@wcW)y8++N`^|x(B4-iyyreiYd?mx?~|0=cJ#3j*VZKo7+a^dFXj63(cSDz zl;4Li5o-L$dSv@-oG0~()tzeb=&^U?uKt65!!hanYvU)3STV*K+Hx$$7!_<$>#5*( zR-kMVCt71jzC^!0$O ze?%mLZ&uqII3KR#4aOEq+%*2D--fQmUnQRTz*iB6{GTEJnkm0g=U+trb(v2dCyPQX z2l_XaO&@)qzKD}?n7`-zpb+r9+;PmUP;11A1H$-j=i zp0j%u)|sCFB(hireqm*q)(xoVh!7#Hv3z2^JWrPAwv<}oLjv=OMFeubj6Qz+8rCk5 zv9%d z*KNY8?f&?Y;+6Au+s*H{w0)??8k4+tB69ulqUSB)(sdt{b>kkDv`W6>BvsEJUoqvS z=)C7cXXCFjHX7$J$azD~(>Pz4GC$gm7r%e4_>kWH{o*u?<5tA`*qk%O_7N?is>F=e z^L8C)uiz@rsYJV|c9wp$L7#V|`ka<2L)V`O9`f9Hou8%h|HntjH|vnA^M8sl-b(+} z`qs1E%{FqMD=uK0lAb&_jsK6=sAKza7smeaG@dPqwO=m!nnm%*exG=`9z-7TDu4Y8 zs$GhGviD_fp6Q=uSk6;hx_&7!1}d33-Awbo60>Q z`zy}EZ*$IQ3StjWKv;8wqLb%ray>&n+b8hp)O=d89?vB&tl`~SwhxcOPQm?)4jp|B zYq-M}&w8|Z4rFTm_7_?n$QG8Pzrc%l>;!msjO$&IfcYBz5%+7*jl3`?Js;IJr;E=; zx6L0CBW;=UikX&vD9@M0c~=;R<+wV$q~JRJlD5V5jj`0JziZq1D%$wgo9(;ai`eIH zi!Zf3!~EMPL0@O8W8MEm9feVKyj6Tf*Wq3N5Ad0nPGfxk&!DZYLyr6D zH#tv&E_4Nb?Gtg2Hj?ua+sJ*gxYOW)GqireHKj4G_{771qsKxw@^el3U(@-yroKL+ zeE0XS9Bx5h{|fqNpGC%XVjs@gp?o(7KJxAl3$F6{!K062{H;n%+4c^e!z^b!FWe_y z5F^sp{*H6Q`ee2bpIso|A@gNl&#u(6q>TUdEw1-vyS@8Cfm|<-kK8GL0BgQAeHd?! z5A*Jt8W`6+y!kK*&) z;wzfZVe*ml$5$Y8-?&xFr`kf!!Nq#4{#~VEL)?QKHnfCo=)v<6ZO4u6%8ncV31@=4 z5sU7JIA7R-*g_xp-{P|mjJH>5BaD@o*L)pq0y~Cv{5EDs56`Oo?XPGH+ALyw_luN| zwvV=<`-yw&{?QB3y8En3_uoE$w+-F1K824riqC&GZ1~#^VH+N=;y7!&w+(+gi?rwu zS90EkUhpID`S?rQ-gCG)wxB(�S5Evz_G_@{pWA5WArZKADAbS6g4d9-eR7J-1{m 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

FPbh?KLVQY;0-z(v8R`f#Xa9W_Z->XLpC(0 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 DqIW;c literal 0 HcmV?d00001 diff --git a/lib/liblpsolve55.dylib b/lib/liblpsolve55.dylib new file mode 100755 index 0000000000000000000000000000000000000000..1e4b968327758a739b3d4ad1741976587df45e8c GIT binary patch literal 585048 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

DRomGlQo@})dZf$xqSxibqKZ}5 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 literal 0 HcmV?d00001 diff --git a/lib/linux_liblpsolve55.a b/lib/linux_liblpsolve55.a new file mode 100644 index 0000000000000000000000000000000000000000..ca78fe530d538a950b4746211e54f7cb15247d18 GIT binary patch literal 654572 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 z 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

4#0vt02#XxWaJ7)g~?>x)Ya5JrUin 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°N-zP=QEPnC}T+c~Zu_8+-}&1OHBdo1 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 z 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 MN|?)C(xCkNFNyW}CIA2c literal 0 HcmV?d00001 diff --git a/ma.H b/ma.H new file mode 100644 index 0000000..f031814 --- /dev/null +++ b/ma.H @@ -0,0 +1,278 @@ +/*************************************************************************** + ma.h - Multiplicity Automata + ------------------- + begin : Tue Jul 16 2002 + copyright : (C) 2002 by Yann Esposito + email : esposito@cmi.univ-mrs.fr +***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +/*_________________________________________________________________________*\ + Un automate fini fonctionnel se défini comme un quintuplet : + Sigma : l'alphabet, un ensemble fini de lettre. + Ici, les lettre seront des mots. + Q : L'ensemble des états. Pour l'instant on se limite aux entiers. + iota : une fonction de Q dans IR + tau : une fonction de Q dans IR + phi : une fonction de Q x Sigma x Q dans IR + + \***************************************************************************/ + +#ifndef MA_H +#define MA_H + +#include "general.H" +#include "sample.H" +#include + +typedef set < State > StateSet; // type Ensemble d'états +typedef map < State, float >SFunc; // Type fonction State --> IR +typedef map < Lettre, SFunc > LettreSFunc; // Type fonction Lettre x State --> IR +// typedef hmext::hash_map < State, LettreSFunc > Graph; // Le type Graph +typedef map < State, LettreSFunc > Graph; // Le type Graph +struct ordre_transition +{ + bool operator()(const Transition t1, const Transition t2) const + { + return + (t1.qarr < t2.qarr) || + ( + (t1.qarr == t2.qarr) && + ( + (t1.a < t2.a) || + ( + (t1.a == t2.a) && (t1.qdep < t2.qdep) + ) + ) + ); + } +}; +typedef map TransitionFunction; + + +typedef enum { paffa, paalergia, pamdi} FormatSauvegarde; + +class MA +{ + // ---------------- Structure de donnée ------------------------ +public: + // Le nom du MA + string name; +protected: + // Le dictionnaire + Dictionnaire alph; // permet d'associer des chaines de caractères aux lettre + // l'alphabet + Alphabet Sigma; + // L'ensemble d'états + StateSet Q; + // La fonction iota + SFunc iota; + // La fonction tau + SFunc tau; + // La fonction phi; + Graph phi; + + // ------------------------- Méthodes --------------------------- +protected: // méthodes internes + // renvoie un flottant aleatoire compris entre min et max + float random (float min = 0, float max = 1) const; + // renvoie vrai si x est à peu près égal à 1; + inline bool simeqone (double x) const + { + return ((x > 0.9999) && (x < 1.0001)); + } + + // --- Constructeurs et destructeurs -- +public: + MA (int nb_lettres = 0, int nb_etats = 0); + ~MA (); + + // --- Affichage --- + // Renvoie la chaine de caractère d'affichage + string message (void) const; + // Affichage sous la sortie standart + RESULT affiche (void) const; + + // --- Input output --- + // Sauvegarde le MA dans Filename + RESULT save (ofstream &fp, const FormatSauvegarde c_format = paffa) const; + RESULT save (const char *Filename, const FormatSauvegarde format = paffa) const; + inline RESULT save (const string Filename) const {return save (Filename.c_str ());} + // Charge le MA de Filename + RESULT load (const char *Filename); + RESULT load (string Filename) {return load (Filename.c_str ());} + + // save in dot format + RESULT save_dot (const char *Filename, + const int precision = 2, + const bool noms_etats = false, + const bool multiple_trans = false) const; + RESULT save_dot (const string Filename, + int precision = 2, + bool noms_etats = false, + bool multiple_trans = false) const; + + // --- Accesseurs --- + // true if the MA is empty + inline bool empty() const {return Q.empty();} + // return the size of the MA + inline unsigned int size () const {return Q.size ();} + // return the number of letter of the MA + inline unsigned int nb_lettres () const {return Sigma.size ();} + // return safely iota[q] (even if iota[q]=0) + inline float val_iota (const State q) const { + SFunc::const_iterator i = iota.find (q); + return i == iota.end () ? 0 : i->second; + } + // return safely tau[q] (even if tau[q]=0) + inline float val_tau (const State q) const{ + SFunc::const_iterator i = tau.find (q); + return i == tau.end () ? 0 : i->second; + } + // return safely phi[t] (even if phi(t)=0 ) + inline float val_phi (const Transition &t) const { + return val_phi(t.qdep, t.a, t.qarr); + } + // return safely phi[t] (even if phi(t)=0 ) + inline float val_phi (const State q, const Lettre a, const State s) const { + Graph::const_iterator qi = phi.find (q); + if (qi == phi.end ()) return 0; + LettreSFunc::const_iterator ai = qi->second.find (a); + if (ai == qi->second.end ()) return 0; + SFunc::const_iterator si = ai->second.find (s); + if (si == ai->second.end ()) return 0; + return si->second; + } + + // The transitionFunction T is the set of all transitions of the MA + void allTransitions(TransitionFunction &T) const; + // The stateFucntion S is the set of all state of the MA + void allStates(SFunc &S) const; + + // the delta function + StateSet delta(const State q, const Word &w) const; + StateSet delta(const StateSet &R, const Word &w) const; + + // direct read only accessor + inline Dictionnaire dictionnaire(void) const {return alph;}; + + // --- Modifieurs --- + // Ajout une lettre par defaut à l'alphabet + Lettre addLettre (void); + // Add the letter buf + Lettre addLettre (const TrueLettre & buf); + // Ajoute un état + //State addState (const float init = 0, const float term = 1); + State addNewState (const float init, const float term); + + // Ajout l'état q s'il n'existe pas déjà + State addState (const State q, const float init = 0, const float term = 1); + + // Fonction qui ajoute une transition + RESULT addTransition (const Transition & t, const float val); + // Ajout d'une transition + RESULT addTransition (const State qdep, const Lettre a, const State qarr, const float val); + // erase badstate + RESULT erase (State badstate); + // clean transitions with parameter between minval and maxval + RESULT erase_transitions (const double maxval = 0, const double minval = 0); + // erase cleanly the transition phi(qbeg, l ,qend) + RESULT eraseTransition(const State qbeg, const Lettre l, const State qend); + + // Become a Random MA + RESULT becomeRandom (const int nb_etats, // le nombre d'états + const int nb_lettres, // le nombre de lettres + const int num_graphe = 0, // le numero du graphe + const float densite = 0.3, // densité du ffa (0 ffa vide, 1 ffa complet) + const float prob_init = 0.3, // la probabilité pour un état d'etre initial + const float prob_term = 0.3, // probabilité pour un état d'être terminal + const float min_trans = 0, // la valeur minimale des transitions + const float max_trans = 1); // la valeur maximale des transitions + + // Cree un MA prefixe aleatoire + RESULT becomeRandomPrefix (const int nb_etats, // le nombre d'états + const int nb_lettres, // le nombre de lettres + const int num_graphe = 0, // le numero du graphe + const float densite = 0.3, // densité du ffa (0 ffa vide, 1 ffa complet) + const float prob_init = 0.3, // la probabilité pour un état d'etre initial + const float prob_term = 0.3, // probabilité pour un état d'être terminal + const float min_trans = 0, // la valeur minimale des transitions + const float max_trans = 1); // la valeur maximale des transitions + + // Cree un MA aleatoire avec un nombre d'aretes maximal fixé + RESULT becomeRandomMax (const int nb_etats, const int nb_lettres, + const int num_graphe=0, const int nb_succ=2, + const int nb_init=1, const int nb_term=INT_MAX, + const float min_trans=0, const float max_trans=1); + + // Cree un MA aleatoire avec le maximum de controle + // nb_etats : number of states of the MA + // nb_lettres : number of letters of the alphabet of the MA + // num_graphe : if different of 0, the same number gives always the same MA + // max_nb_init : the maximal number of initial states + // max_nb_succ : the maximal number of successors by states-letter + // max_nb_term : the maximal number of terminal states + // min_trans : minimal value of transitions + // max_trans : maximal value of transitions + // min_iota : minimal value for iota(q) + // max_iota : maximal value for iota(q) + // min_tau : minimal value for tau(q) + // max_tau : maximal value for tau(q) + // nomalize : if different of 0, normalize sum of iota and sum of tau + successor transitions + // prob_init : probability for a state to be initial + // prob_trans : probability to create each transition + // prob_term : probability for a state to be terminal + RESULT becomeRandomControl (const int nb_etats, const int nb_lettres, const int num_graphe, const int max_nb_succ, const int max_nb_init, const int max_nb_term, const float min_trans, const float max_trans, const float min_iota, const float max_iota, const float min_tau, const float max_tau, const float normalization, const float prob_init, const float prob_trans, const float prob_term); + + + RESULT becomeComplete (const int nb_etats, const int nb_lettres); + + // Fonction qui rend le MA vide (pas d'états pas de lettre) + void vide (); + // exactly as vide, clear the MA + inline void clear() { vide(); } + // emmonde the MA + // delete all reachable states and all states from which no state can be reached + RESULT emmonde(void); + + + // --- Fonctions dŽpendant de l'objet --- + // the next word using the alphabet Sigma + void next (Word & w) const; + // renvoie la chaine correspondant au mot + string affiche (const Word & w) const; + void normaliseVecteur(SFunc &V) const; + RESULT val_PSe(SFunc &PSe) const; + // generate a word from the model using the P_r function where r + // is the rationnal serie of the MA + // genere un mot en corelation avec la distribution P_r associe + // au MA + RESULT genere_mot(Word &w, const bool safe = true); + // genere un échantillon de mots + RESULT genere_echantillon(const int taille, Sample &S, const int num_echantillon=0); + // genere un échantillon de mots + RESULT genere_echantillon(const int taille, Sample &S, const char *Filename, const int num_echantillon=0); + + // --- Test --- + // Teste la cohérence de la structure de donnée + bool coherent (void) const; + // Teste si le MA est coherent et est un SPFA. valeur de iota, tau et phi dans [0,1] + bool isSPFA (void) const ; + // renvoi vrai si le MA est un PFA + bool isPFA (void) const; + + private: + RESULT renormalize_state(const State q, const float renormalization, const float min_tau, const float max_tau, const float min, const float max); + + +}; + +#endif diff --git a/ma.cpp b/ma.cpp new file mode 100644 index 0000000..ce68748 --- /dev/null +++ b/ma.cpp @@ -0,0 +1,2562 @@ +/*************************************************************************** + ma.C + ------------------- + begin : Tue Jul 16 2002 + copyright : (C) 2002 by Yann Esposito + email : esposito@cmi.univ-mrs.fr +***************************************************************************/ + +/* + Pour les notes, voir le fichier "ffa.h". + See "ffa.h" file to view notes. +*/ + +#include "ma.H" +#include +#include +#include +#include +#include "simplex.H" + +RESULT MA::save_dot (const string Filename, int precision, bool noms_etats, + bool multiple_trans) const +{ + return save_dot (Filename.c_str (), precision, noms_etats, multiple_trans); +} + + +/// ------- MÈthodes internes --------- +float +MA::random (float min, float max) const +{ + if (PFA_SAFE) + { + assert (min <= max); + } + return ((((float) rand () + 1) / INT_MAX) * (max - min)) + + min; +} + +/// --------------------- Constructeurs et Destructeurs ---------------------- +// Constructeur par dÈfaut +MA::MA (int nb_lettres, int nb_etats) +{ + // Initialisation de l'alphabet + int i; + for (i = 0; i < nb_lettres; ++i) + { + Sigma.insert ('a' + i); + } + + // Initialisation de l'ensemble d'Ètats + for (i = 0; i < nb_etats; ++i) + Q.insert (i); + + // Initialisation de iota + StateSet::iterator q; + for (q = Q.begin (); q != Q.end (); ++q) + iota[*q] = 0; + if (nb_etats != 0) + iota[*(Q.begin ())] = 1; + + // Initialisation de tau + for (q = Q.begin (); q != Q.end (); ++q) + tau[*q] = 1; + + // Initialisation de phi + // On laise phi complËtement vide, l'automate n'a pas d'arÃte ‡ l'initialisation. +} + +// Destructeur par dÈfaut +MA::~MA () +{} + + +/// -------------------------- Affichage ---------------------------------- + +// Fonction d'affichage d'automate +string MA::message (void) const +{ + string + mesg; // La variable qui va contenir le message a afficher. + char + flottant[3 * (sizeof (float)) + 1]; // un tableau suffisamment grand pour Ècrire un flottant en dÈcimal. + mesg = "--- AFFICHAGE de " + name + " ---\n"; + + if (PFA_VERBOSE) + { + // Affichage du dictionnaire + for (Dictionnaire::const_iterator d = alph.begin (); + d != alph.end (); ++d) + { + mesg += "alph["; + mesg += d->first; + mesg += "]=" + d->second + " ; "; + } + mesg += "\n"; + } + + // Affichage de l'alphabet + Alphabet::const_iterator l; + mesg += "Sigma = {"; + if (Sigma.empty ()) + { + mesg += "}\n"; + } + else + { + for (l = Sigma.begin (); l != Sigma.end ();) + { + if (alph.find (*l) == alph.end ()) + { + mesg += *l; + } + else + { + mesg += (alph.find (*l))->second; + } + + if (++l != Sigma.end ()) + { + mesg += ", "; + } + else + { + mesg += "}\n"; + } + } + } + + // Affichage des Ètats + StateSet::const_iterator e; + mesg += "Q = {"; + e = Q.begin (); + if (e == Q.end ()) + { + mesg += "}\n"; + } + while (e != Q.end ()) + { + sprintf (flottant, "%d", *e); + mesg += flottant; + e++; + if (e != Q.end ()) + { + mesg += ", "; + } + else + { + mesg += "}\n"; + } + } + + // Affichage de iota + SFunc::const_iterator s; + stringstream convert; + string nombre; + mesg += "iota : "; + for (s = iota.begin (); s != iota.end (); ++s) + { + mesg += "("; + sprintf (flottant, "%d", s->first); + mesg += flottant; + mesg += ", "; + //convert << s->second; + //convert >> nombre; + //mesg += nombre; + sprintf (flottant, "%f", s->second); + mesg += flottant; + mesg += ") "; + } + mesg += "\n"; + + // Affichage de tau + mesg += "tau : "; + int i=0; + for (s = tau.begin (); s != tau.end (); ++s) + { + mesg += "("; + sprintf (flottant, "%d", s->first); + mesg += flottant; + mesg += ", "; + sprintf (flottant, "%f", s->second); + mesg += flottant; + mesg += ") "; + if (i++%5 == 0) { + mesg += "\n"; + } + } + mesg += "\n"; + + // Affichage de phi + mesg += "phi : "; + if (phi.empty ()) + mesg += "vide"; + else + { + LettreSFunc::const_iterator a; + Graph::const_iterator q; + for (q = phi.begin (); q != phi.end (); q++) + { + for (a = q->second.begin (); + a != q->second.end (); a++) + { + for (s = a->second.begin (); + s != a->second.end (); s++) + { + mesg += "("; + sprintf (flottant, "%d", + q->first); + mesg += flottant; + mesg += ","; + + // on Ècrit la bonne lettre + if (alph.find (a->first) == + alph.end ()) + mesg += a->first; + else + mesg += alph.find (a->first)->second; + + mesg += ","; + sprintf (flottant, "%d", s->first); + mesg += flottant; + mesg += ") = "; + sprintf (flottant, "%f", s->second); + mesg += flottant; + mesg += " ; "; + } + } + mesg+="\n"; + } + } + mesg += "\n"; + + return mesg; +} + +// Chargement d'un fichier dot pour l'affichage de graphe +RESULT +MA::save_dot (const char *Filename, + const int precision, + const bool noms_etats, + const bool multiples_trans) const +{ + try + { + if (Filename == NULL) + { + throw 0; + } + + ofstream fp (Filename); + if (fp == NULL) + { + throw 1; + } + fp.precision (precision); //fp.flags(ios::scientific); + + if (!name.empty ()) + fp << "digraph \"" << name << "\" {" << endl; + else + fp << "digraph G {" << endl; + + // On met le graphe en mode horizontal (Left to Right) + fp << "graph [rankdir=LR]" << endl; + + Graph::const_iterator q; + StateSet::const_iterator e; + LettreSFunc::const_iterator a, b; + SFunc::const_iterator s, r; + StateSet W; + Dictionnaire::const_iterator tl; + + for (e = Q.begin (); e != Q.end (); ++e) + { + // On crÈe la flÃche d'initialisation si il y a lieu + if ((iota.find (*e) != iota.end ()) && (iota.find (*e)->second != 0)) + { + fp << "iota" << *e << "[shape=plaintext, label = "; + fp << (iota.find (*e))-> + second << " psfrag = \"$"; + fp << (iota.find (*e))-> + second << "$\", height=.15]" << + endl; + fp << "iota" << *e << " -> " << *e << + "[minlen=1]" << endl; + } + + // on cree l'etat avec ses attributs + fp << *e; + fp << " [ label = \""; + if (noms_etats) + { + fp << *e << "\\n"; + } + // if ((iota.find(*e) != iota.end()) && + // (iota.find(*e)->second != 0)) { + //fp << "i=" << (iota.find(*e))->second << "\\n"; + // + if ((tau.find (*e) != tau.end ()) + && (tau.find (*e)->second != 0)) + { + fp << (tau.find (*e))->second; + fp << "\",peripheries=2"; + } + else + { + fp << "\""; + } + fp << "]" << endl; + + // on ecrit ses successeurs + q = phi.find (*e); + if (q != phi.end ()) + { + if (multiples_trans) + { + for (a = q->second.begin ();a != q->second.end (); a++) + { + for (s =(a->second).begin ();s !=(a->second).end ();s++) + { + if (s->second !=0) + fp << "\t" << q->first; + fp << " -> " << s->first; + fp << "[label=\""; + tl = alph.find(a->first); + if (tl == alph.end()) { + throw 3; + } + fp << tl->second; + fp << "," << s->second; + fp << "\"]" << endl; + } + } + } + else + { + // le W sert a ne pas s'occuper plusieurs fois de l'etat d'arrive + W.clear(); + for (a = q->second.begin (); a != q->second.end (); a++) + { + for (s =(a->second).begin ();s !=(a->second).end ();s++) + { + if (s->second !=0) + { + if (W.find(s->first)==W.end()) + { + W.insert (s->first); + fp << "\t" << q->first << " -> " << s->first; + fp << "[label=\""; + tl=alph.find(a->first); + if (tl == alph.end()) + throw 3; + fp << tl->second << "," << s->second; + for (b = a; ++b != q->second.end ();) + { + r = b->second.find (s->first); + if (r != b->second.end ()) + { + fp << "\\n"; + tl = alph.find (b->first); + if (tl == alph.end()) + throw 3; + fp << tl->second << "," << r->second; + } + } + fp << "\"]" << endl; + } + } + } + } + } + } + } + + fp << "}" << endl; + return VAL (0); + } + catch (int erreur) + { + if (PFA_VERBOSE) + { + cerr << "ERREUR MA::save_dot" << endl; + switch (erreur) + { + case 0: + cerr << "\tFilename == NULL !!!" << endl; + break; + case 1: + cerr << "\tErreur d'ouverture du fichier " << Filename << endl; + break; + case 3: + cerr << "\tErreur du dictionnaire toutes les lettres ne sont pas definies" << endl; + default: + cerr << "Erreur n∞" << erreur << endl; + break; + } + } + return ERR (erreur); + } +} + +// Fonction d'affichage d'automate sur la sortie standart +RESULT MA::affiche (void) const +{ + cout << message (); + return VAL (0); +} + +/// --------------------- Entree sortie su fichier ------------------------------ + +RESULT MA::save (ofstream &fp, const FormatSauvegarde c_format) const +{ + try + { + // les itÈrateur pour la structure + Graph::const_iterator q; + LettreSFunc::const_iterator a; + SFunc::const_iterator s; + StateSet::const_iterator e; + Dictionnaire::const_iterator l; + + // la precision de sortie est maximale + fp.precision (20); + // first case format ffa or mdi + switch (c_format) + { + case paffa: + // calculation of the number of edges + // Entete writing + fp << "% MA file generated" << "\n"; + fp << "name \t" << name << "\n"; + + fp << "alph\n"; + for (l=alph.begin() ; l != alph.end() ; ++l) { + fp << l->first << " \t" << l->second << "\n"; + } + fp << ".\n"; + + fp << "iota\n"; + for (s=iota.begin() ;s != iota.end() ; ++s) { + fp << s->first << " \t" << s->second << "\n"; + } + fp << ".\n"; + + fp << "tau\n"; + for (s=tau.begin() ; s != tau.end() ;++s) { + fp << s->first << " \t" << s->second << "\n"; + } + fp << ".\n"; + + fp << "phi\n"; + for (q=phi.begin() ; q != phi.end() ; ++q) { + for (a = q->second.begin() ; a != q->second.end() ; ++a) { + for (s=a->second.begin() ; s != a->second.end() ; ++s) { + fp << q->first << " \t"; + fp << a->first << " \t"; + fp << s->first << " \t"; + fp << s->second << "\n"; + } + } + } + fp << ".\n"; + + return 0; + break; + + case paalergia: + // =========== Format alergia !!! format avec perte d'information !!! ==== + // =========== il faut travailler avec des PDFAs !!!!!!!!!! ============== + if (phi.find (0) == phi.end ()) + throw - 3; + + for (q = phi.begin (); q != phi.end (); ++q) + { + for (a = q->second.begin (); + a != q->second.end (); ++a) + { + for (s = a->second.begin (); + s != a->second.end (); ++s) + { + fp << q->first << " "; + fp << alph.find (a->first)->second; + fp << " " << s->first; + fp << " " << s->second << endl; + } + } + } + return 0; + break; + default: + throw - 4; + } + } + catch (int e) + { + if (PFA_VERBOSE) + { + cerr << "ERROR in MA::Save !!!!" << endl; + cerr << " \t"; + switch (e) + { + case -3: + cerr << "There is no initial state" << + endl; + case -4: + cerr << "unrecognized format : " << + c_format << endl; + default: + cerr << "Erreur non prise en compte !" << + endl; + } + } + return e; + } + catch (...) + { + if (PFA_VERBOSE) + { + cerr << "ERROR in MA::Save !!!" << endl; + cerr << "Unexpected error *!#@???" << endl; + } + return ERR (0); + } +} + +// Sauvegarde le MA dans Filename +RESULT +MA::save (const char *Filename, const FormatSauvegarde c_format) const +{ + try { + // On ouvre le fichier + if (Filename == NULL) + throw -1; + ofstream fp (Filename); + if (!fp.good ()) + throw -2; + + return MA::save(fp, c_format); + } + catch (int e) { + if (PFA_VERBOSE) + { + cerr << "ERROR in MA::Save !!!!" << endl; + cerr << " \t"; + switch (e) + { + case -1: + cerr << "Filename == NULL !!!" << endl; + case -2: + cerr << "I can't open the file" << + Filename << endl; + default: + cerr << "Erreur non prise en compte !" << + endl; + } + } + return e; + } +} + +// erase cleanly all transitions with parameter between minval and maxval +RESULT MA::erase_transitions (const double maxval, const double minval) +{ + Graph::iterator q, qtmp; + LettreSFunc::iterator a, atmp; + SFunc::iterator s, stmp; + + // erase for iota + for (s=iota.begin() ; s != iota.end() ; ) { + if ((s->second >= minval) && (s->second <= maxval)) { + stmp = s; + ++stmp; + iota.erase (s); + s = stmp; + } + else { + ++s; + } + } + + // erase for tau + for (s=tau.begin() ; s != tau.end() ; ) { + if ((s->second >= minval)&& (s->second <= maxval)) { + stmp = s; + ++stmp; + tau.erase (s); + s = stmp; + } + else { + ++s; + } + } + + // erase for transitions + for (q = phi.begin (); q != phi.end ();) { + for (a = q->second.begin (); a != q->second.end ();) { + for (s = a->second.begin (); s != a->second.end ();) { + if ((s->second >= minval) && (s->second <= maxval)) { + stmp = s; + ++stmp; + a->second.erase (s); + s = stmp; + } + else { + ++s; + } + } + if (a->second.empty ()) { + atmp = a; + ++atmp; + q->second.erase (a); + a = atmp; + } + else { + ++a; + } + } + if (q->second.empty ()) { + qtmp = q; + ++qtmp; + phi.erase (q); + q = qtmp; + } + else { + ++q; + } + } + + return 0; +} + + +// erase cleanly the transition phi(qbeg,l,qend) +RESULT MA::eraseTransition(const State qbeg, const Lettre l, const State qend) { + Graph::iterator q; + LettreSFunc::iterator a; + SFunc::iterator s; + + q = phi.find(qbeg); + if (q != phi.end ()) + { + a = q->second.find(l); + if (a != q->second.end ()) + { + s = a->second.find(qend); + if (s != a->second.end ()) + { + a->second.erase (s); + } + + if (a->second.empty ()) + { + q->second.erase (a); + } + } + if (q->second.empty ()) + { + phi.erase (q); + } + } + return VAL(0); +} + + +// emmonde l'automate +RESULT MA::emmonde(void) { + // --- Explication de l'algorithme ------ + // On fait un parcour en profondeur en notant tous les Ètats atteint en partant + // des sources (les Ètats initiaux) + // Puis on inverse le graphe et on refait un parcours en profondeur en partant + // des Ètats terminaux. + // Les Ètat atteignables par les Ètats initiaux et qui ne sont pas atteint + // par les Ètats terminaux du graphe inverse sont des Ètats ‡ supprimer. + // --- Fin de l'explication de l'algorithme --- + + // d'abord le parcours inverse + // 1 - On crÈe le graphe inverse + Graph Inv; // The inverse graph + Graph::iterator q; // some state + LettreSFunc::iterator a; // some letter + SFunc::iterator s, r; + StateSet Qir; // set of states from which we can reach a terminal state + StateSet Q2; // set of reachable states + StateSet W; // set for algorithm + StateSet BadStates; // set of bad states + State etat_cour; // current state + + // On inverse le graphe Inv(r,a,q) = phi (q,a,r) + for (q = phi.begin (); q != phi.end (); ++q) + { + for (a = q->second.begin (); a != q->second.end (); ++a) + { + for (s = a->second.begin (); s != a->second.end (); ++s) + { + Inv[s->first][a->first][q->first] = s->second; + } + } + } + + // Pour chaque Ètat terminal, on regarde l'ensemble des Ètats que + // l'on atteint + for (r = tau.begin (); r != tau.end (); ++r) + { + W.insert (r->first); + Qir.insert (r->first); + } + + while (!W.empty ()) + { + etat_cour = *(W.begin ()); + W.erase (W.begin ()); + q = Inv.find (etat_cour); + if (q != Inv.end ()) + { + for (a = q->second.begin (); a != q->second.end (); ++a) + { + for (s = a->second.begin (); s != a->second.end (); ++s) + { + if (Qir.find (s->first) == Qir.end ()) + { + Qir.insert (s->first); + W.insert (s->first); + } + } + } + } + } + // Qir contient tous les Ètats atteignables dans le graphe inverse + + // Pour chaque Ètat initial on regarde si on tombe bien dans + // l'ensemble des Ètats qui atteignent un Ètat terminal. + W.clear() ; // inutile mais au cas o˘ + for (r = iota.begin (); r != iota.end (); ++r) + { + W.insert (r->first); + Q2.insert (r->first); + } + + while (!W.empty ()) + { + etat_cour = *W.begin (); + W.erase (W.begin ()); + q = phi.find (etat_cour); + if (q != phi.end ()) + { + for (a = q->second.begin (); a != q->second.end (); ++a) + { + for (s = a->second.begin (); s != a->second.end (); ++s) + { + if (Q2.find (s->first) == Q2.end ()) + { + Q2.insert (s->first); + W.insert (s->first); + } + + if (Qir.find (s->first) == Qir.end ()) + { + BadStates.insert (s->first); + } + + } + } + } + } + // Q2 contient l'ensemble des Ètats atteignables + // BadStates contient l'ensemble des Ètats accessibles ‡ partir + // desquels on ne peut atteindre un Ètat non terminal + + // Suppressions de tous les Ètats de BadStates + StateSet::iterator bs; + for (bs = BadStates.begin (); bs != BadStates.end (); ++bs) + { + erase (*bs); + } + + // suppression des Ètats non accessibles + BadStates=Q; + for (bs = BadStates.begin() ; bs != BadStates.end() ; ++bs) + { + if (Q2.find(*bs) == Q2.end()) + { + erase(*bs); + } + } + return VAL(0); +} + + +// Charge le MA de Filename +RESULT MA::load (const char *Filename) +{ + try + { + // on modifie le ffa donc on perd l'attribution du ffa + if (Filename == NULL) + throw - 1; + ifstream fp (Filename); + if (fp == NULL) + throw - 2; + fp.precision (30); + string buf; + char tmp[64]; + char c; + bool finfichier; + State q, r, s; + Lettre a; + Dictionnaire::iterator l; + float proba; + + vide (); // on vide le MA + fp >> buf; + if (buf == "%Alergia") + { // ================= cas format alergia ============= + while (fp.good ()) + { // jusqu'‡ la fin du fichier + fp >> q; // on lit l'Ètat de dÈpart + addState (q); + fp >> buf; // on lit la lettre de la transition + a = addLettre (buf); + fp >> r; // on lit l'Ètat d'arrivÈ + addState (r); + fp >> proba; // on lit la probabilitÈ de la transition + addTransition (q, a, r, proba); + } + + // L'Ètat 0 est le seul Ètat initial + iota[0] = 1; + + // On met ‡ jour tau + StateSet::const_iterator iq; + Graph::const_iterator ie; + LettreSFunc::const_iterator ia; + SFunc::const_iterator ir; + + for (iq = Q.begin (); iq != Q.end (); ++iq) + { + proba = 0; // we use proba to make the sum + ie = phi.find (*iq); + if (ie != phi.end ()) + { + for (ia = ie->second.begin (); + ia != ie->second.end (); ++ia) + { + for (ir = ia->second.begin (); + ir != ia->second.end (); + ++ir) + { + proba += ir->second; + } + } + } + tau[*iq] = 1 - proba; + } + } + else if (buf == "%MDI") + { // ========================== cas format MDI ================== + float f1, f2; + int numstates; + char cbuf[20]; + while (fp.good()) { + if (*(buf.begin()) == '%') { // =========================== commentaire ===================== + finfichier = ((fp >> c) == NULL); + while ((!finfichier) && (c != '\n')) + { + finfichier = ((fp.get (c)) == NULL); + } + finfichier = ((fp >> buf) == NULL); + } + else if (buf == "Name") { + getline(fp,name); + fp >> buf; + } + else if (buf == "NumStates") { + fp >> numstates; + for (int i=0 ; i< numstates ; ++i) { + addState(i); + } + fp >> buf; + } + else if (buf == "NumEdges") { + fp >> buf; + fp >> buf; + } + else if (buf == "State") { + fp >> q; // on lit l'etat courant + fp.getline(cbuf,20,'='); + buf = cbuf; + if (buf == " initial") { + fp >> iota[q]; + fp.getline(cbuf,20,'='); + buf = cbuf; + } + if (buf == " final") { + fp >> f1; + fp.get(c); + fp >> f2; + tau[q]=f1/f2; + } + else { + cerr << "PARSE ERROR final : q=" << q << endl; + } + fp >> buf; // on recupere le %Ci=0.xxxxxxx + fp >> buf; // on recupere le numero de l'etat + // on commence a lire les transition sortantes + while ((buf != "State") && (fp.good())) { + fp >> s; // on lit l'etat d'arrive + fp >> buf; // on lit la lettre + // on efface les guillemets + buf.erase(buf.begin()); + buf.erase(--buf.end()); + fp.getline(cbuf,20,'='); + fp >> f1; + fp.get(c); + fp >> f2; + if (buf.empty()) { + tau[q]+=f1/f2; + } + else { + a=addLettre(buf); + addTransition(q,a,s,f1/f2); + //phi[q][a][s]=f1/f2; + } + fp >> buf; // on lit le %Ci=0.xxxxxxx + fp >> buf; + } + } + } + } + else if (buf == "%OLDMA") + { // ================= cas format ffa interne ============= + while (fp.good ()) + { // Tand que l'on est pas ‡ la fin du fichier + if (*(buf.begin()) == '%') + { // =========================== commentaire ===================== + finfichier = ((fp >> c) == NULL); + while ((!finfichier) && (c != '\n')) + { + finfichier = + ((fp.get (c)) == + NULL); + } + finfichier = ((fp >> buf) == NULL); + } + // ============================== State ======================== + else if (buf == "State") + { + // --------------- Lecture de la ligne initiale ---------------- + fp >> q; // on lit l'Ètat de dÈpart + Q.insert (q); // on ajoute l'etat q + sprintf (tmp, "%d", q); + finfichier = ((fp >> buf) == NULL); // on lit la suite + while ((buf != "State") + && (buf != tmp) + && (!finfichier)) + { + if (buf == "c") + { + fp >> buf; // on lit le = + fp >> buf; // on lit le chiffre mais on en fait rien + } + else if (buf == "i") + { // on lit la probabilitÈ d'Ãtre initial + fp >> buf; // on lit le = + fp >> proba; // on lit la probabilitÈ + if (proba != 0) + iota[q] = + proba; + } + else if (buf == "f") + { // on lit la probabilitÈ d'Ãtre terminal + fp >> buf; // on lit le = + fp >> proba; // on lit la probabilitÈ + if (proba != 1) + tau[q] = 1 - + proba; + } + finfichier = ((fp >> buf) == NULL); // on lit la suite + } + // ---------------- Lecture des transitions sortantes ---------------- + r = q; + while ((buf != "State") + && (!finfichier)) + { + if (PFA_VERBOSE) + { + if (buf != tmp) + { + cerr << "load WARNING !" << endl; + cerr << "La premiËre lettre d'une colone ne correspond pas ‡ l'Ètat" << endl; + } + } + fp >> s; // on lit l'Ètat d'arrivÈ + fp >> buf; // on lit la lettre + + a = addLettre(buf); + //~ // on cherche la lettre correspondante + //~ for (l = alph.begin (); + //~ (l != alph.end ()) + //~ && (l->second != buf); + //~ l++) + //~ ; + //~ if (l == alph.end ()) + //~ { // si on ne retrouve pas la lettre + //~ a = addLettre (); // on ajoute une lettre + //~ alph[a] = buf; // ‡ laquelle on fait correspondre la bonne chaine de caractËre + //~ } + //~ else // sinon + //~ a = l->first; // on attribu la lettre en cours. + + fp >> buf; // on lit 'p' + fp >> buf; // on lit '=' + fp >> proba; // on lit la proba de l'arÃte + + phi[q][a][s] = proba; // on insËre l'arÃte + finfichier = ((fp >> buf) == NULL); // on lit la lettre suivante. + } + } + else + { // Autres cas, on ne fait rien d'autre qu'avancer + fp >> buf; + } + } + { // ================= cas format ffa interne ============= + while (fp.good ()) + { // Tand que l'on est pas ‡ la fin du fichier + if (*(buf.begin()) == '%') + { // =========================== commentaire ===================== + finfichier = ((fp >> c) == NULL); + while ((!finfichier) && (c != '\n')) + { + finfichier = + ((fp.get (c)) == + NULL); + } + finfichier = ((fp >> buf) == NULL); + } + // ============================== State ======================== + else if (buf == "State") + { + // --------------- Lecture de la ligne initiale ---------------- + fp >> q; // on lit l'Ètat de dÈpart + Q.insert (q); // on ajoute l'etat q + sprintf (tmp, "%d", q); + finfichier = ((fp >> buf) == NULL); // on lit la suite + while ((buf != "State") + && (buf != tmp) + && (!finfichier)) + { + if (buf == "c") + { + fp >> buf; // on lit le = + fp >> buf; // on lit le chiffre mais on en fait rien + } + else if (buf == "i") + { // on lit la probabilitÈ d'Ãtre initial + fp >> buf; // on lit le = + fp >> proba; // on lit la probabilitÈ + if (proba != 0) + iota[q] = + proba; + } + else if (buf == "f") + { // on lit la probabilitÈ d'Ãtre terminal + fp >> buf; // on lit le = + fp >> proba; // on lit la probabilitÈ + if (proba != 1) + tau[q] = 1 - + proba; + } + finfichier = ((fp >> buf) == NULL); // on lit la suite + } + // ---------------- Lecture des transitions sortantes ---------------- + r = q; + while ((buf != "State") + && (!finfichier)) + { + if (PFA_VERBOSE) + { + if (buf != tmp) + { + cerr << "load WARNING !" << endl; + cerr << "La premiËre lettre d'une colone ne correspond pas ‡ l'Ètat" << endl; + } + } + fp >> s; // on lit l'Ètat d'arrivÈ + fp >> buf; // on lit la lettre + + a = addLettre(buf); + //~ // on cherche la lettre correspondante + //~ for (l = alph.begin (); + //~ (l != alph.end ()) + //~ && (l->second != buf); + //~ l++) + //~ ; + //~ if (l == alph.end ()) + //~ { // si on ne retrouve pas la lettre + //~ a = addLettre (); // on ajoute une lettre + //~ alph[a] = buf; // ‡ laquelle on fait correspondre la bonne chaine de caractËre + //~ } + //~ else // sinon + //~ a = l->first; // on attribu la lettre en cours. + + fp >> buf; // on lit 'p' + fp >> buf; // on lit '=' + fp >> proba; // on lit la proba de l'arÃte + + phi[q][a][s] = proba; // on insËre l'arÃte + finfichier = ((fp >> buf) == NULL); // on lit la lettre suivante. + } + } + else + { // Autres cas, on ne fait rien d'autre qu'avancer + fp >> buf; + } + } + + } + return 0; + } + + + + else { + stringstream str; + Lettre a; + TrueLettre b; + while (fp.good ()) + { // Tand que l'on est pas ‡ la fin du fichier + if (*(buf.begin()) == '%') + { // =========================== commentaire ===================== + fp.get(c); + while ((fp.good()) && (c != '\n')) { + fp.get (c); + } + fp >> buf; + } + else if (buf == "name") { + fp.get(c); + name+=c; + while ((fp.good()) && (c != '\n')) { + fp.get (c); + name+=c; + } + fp >> buf; + } + else if (buf == "alph") + { // dictionnaire + fp >> buf; + while ((buf != ".") && (fp.good())) { + if (*(buf.begin()) == '%') + { // --- commentaire --- + fp.get(c); + while ((fp.good()) && (c != '\n')) { + fp.get (c); + } + fp >> buf; + } + str << buf; + str >> a; + fp >> b; + Sigma.insert(a); + alph[a]=b; + fp >> buf; + } + fp >> buf; + } + else if (buf == "iota") + { // iota + fp >> buf; + while ((buf != ".") && (fp.good())) { + + if (*(buf.begin()) == '%') + { // --- commentaire --- + fp.get(c); + while ((fp.good()) && (c != '\n')) { + fp.get (c); + } + fp >> buf; + } + + q=atoi(buf.c_str()); + fp >> proba; + Q.insert(q); + iota[q]=proba; + fp >> buf; + } + fp >> buf; + } + else if (buf == "tau") + { // iota + fp >> buf; + while ((buf != ".") && (fp.good())) { + + if (*(buf.begin()) == '%') + { // --- commentaire --- + fp.get(c); + while ((fp.good()) && (c != '\n')) { + fp.get (c); + } + fp >> buf; + } + + q=atoi(buf.c_str()); + fp >> proba; + Q.insert(q); + tau[q]=proba; + fp >> buf; + } + fp >> buf; + } + else if (buf == "phi") { + fp >> buf; + while ((buf != ".") && (fp.good())) { + + if (*(buf.begin()) == '%') + { // --- commentaire --- + fp.get(c); + while ((fp.good()) && (c != '\n')) { + fp.get (c); + } + fp >> buf; + } + + q=atoi(buf.c_str()); + fp >> a; + fp >> s; + fp >> proba; + + if (alph.find(a) == alph.end()) { + cerr << "!!! Lettre : " << a << endl; + throw -3; + } + + Q.insert(q); + Q.insert(s); + phi[q][a][s]=proba; + + fp >> buf; + } + fp >> buf; + } + else + { // Autres cas, on ne fait rien d'autre qu'avancer + fp >> buf; + } + } + } + return VAL(0); + } + catch (int erreur) + { + if (PFA_VERBOSE) + { + cerr << "MA::load" << endl; + switch (erreur) + { + case -1: + cerr << "ERROR in MA::Save !!!!" << endl; + cerr << " \tFilename == NULL !!!" << endl; + break; + case -2: + cerr << "Erreur lors de l'ouverture du fichier : " << Filename << endl; + break; + case -3: + cerr << "Erreur alph n'est pas bien defini, des lettres manques !" << endl; + default: + cerr << "Erreur inconnue ?" << endl; + } + } + return erreur; + } + catch (...) + { + if (PFA_VERBOSE) + { + cout << "MA::load(" << Filename << ")" << endl; + cout << "Erreur inexplicable ?" << endl; + } + return ERR (0); + } +} + + +/// ----------------------- Modifieurs ------------------------------- + +// Fonction qui ajoute une transition +RESULT MA::addTransition (const Transition & t, const float val) +{ + if (PFA_SAFE) + { + assert (Q.find (t.qdep) != Q.end ()); + assert (Sigma.find (t.a) != Sigma.end ()); + assert (Q.find (t.qarr) != Q.end ()); + } + + if (val != 0) + { + phi[t.qdep][t.a][t.qarr] = val; + } + else { + Graph::const_iterator q; + q = phi.find(t.qdep); + if ( q != phi.end()) { + LettreSFunc::const_iterator a = q->second.find(t.a); + if (a != q->second.end()) { + SFunc::const_iterator s = a->second.find(t.qarr); + if (s != a->second.end()) { + phi[t.qdep][t.a][t.qarr] = val; + } + } + } + } + + if (PFA_SAFE) + { + assert (coherent ()); + } + return VAL (0); +} + + +// Ajout une lettre par defaut ‡ l'alphabet +Lettre MA::addLettre (void) +{ + Lettre + a; + if (!Sigma.empty ()) + { + a = *(--(Sigma.end ())) + 1; + } + else + { + a = 'a'; + } + + Sigma.insert (a); + alph[a] = a; + return a; +} + +// Ajout de la lettre buf +Lettre MA::addLettre (const TrueLettre & buf) +{ + // search whether buf is a new letter + Lettre a; + Dictionnaire::iterator l; + for (l = alph.begin (); (l != alph.end ()) && (l->second != buf); ++l) + ; + if (l == alph.end ()) + { // if buf is new then + a = addLettre (); // we add the letter + alph[a] = buf; // and we associate it with buf + } + else { + a = l->first; + } + return a; +} + + +// Ajoute un Ètat +State MA::addNewState (const float init, const float term) +{ + State q; + if (!Q.empty ()) + { + q = *(--Q.end()) + 1; + while (Q.find(q) != Q.end()) + ++q; + } + else + { + q = 1; + } + addState(q,init,term); + return q; +} + + +// Ajoute l'Ètat q s'il n'existe pas +State MA::addState (const State q, const float init, const float term) +{ + if (Q.find (q) == Q.end ()) + { + Q.insert (q); + } + if (init != 0) + iota[q]=init; + if (term != 0) + tau[q]=term; + return q; + if (PFA_SAFE) + assert(coherent()); +} + + +// Ajout d'une transition +RESULT MA::addTransition (const State qdep, const Lettre a, const State qarr, const float val) +{ + if (PFA_SAFE) + { + assert (Q.find (qdep) != Q.end ()); + assert (Sigma.find (a) != Sigma.end ()); + assert (Q.find (qarr) != Q.end ()); + } + if (val != 0) + { + phi[qdep][a][qarr] = val; + } + + if (PFA_SAFE) + { + assert (coherent ()); + } + return VAL (0); +} + +// Cree un MA aleatoire +RESULT MA::becomeRandom (const int nb_etats, const int nb_lettres, + const int num_graphe, const float densite, + const float prob_init, const float prob_term, + const float min_trans, const float max_trans) +{ + float init, term; + int i; + StateSet::const_iterator q, s; + Alphabet::const_iterator a; + + // on vide le MA + vide (); + // on initialise la variable aleatoire + if (num_graphe != 0) + srand (num_graphe); + + // on ajoute les états + for (i = 0; i < nb_etats; i++) + { + if (random () < prob_init) + init = random (min_trans, max_trans); + else + init = 0; + + if (random () < prob_term) + term = random (min_trans, max_trans); + else + term = 0; + + addNewState (init, term); + } + + // on ajoute les lettres + for (i = 0; i < nb_lettres; i++) + { + addLettre (); + } + + // on cree les transitions avec des distributions uniformes + for (q = Q.begin (); q != Q.end (); q++) + { // pour tous les Ètats + for (a = Sigma.begin (); a != Sigma.end (); a++) + { + for (s = Q.begin (); s != Q.end (); s++) + { + if (random () < densite) + { // si on tire un nombre inferieur ‡ la densitÈ, on cree une arete + phi[*q][*a][*s] = + random (min_trans, max_trans); + } + } + } + } + return VAL (0); +} + +// Cree un MA aleatoire +RESULT MA::becomeRandomMax (const int nb_etats, const int nb_lettres, + const int num_graphe, const int nb_succ, + const int nb_init, const int nb_term, + const float min_trans, const float max_trans) +{ + int i; + StateSet::const_iterator q, s; + Alphabet::const_iterator a; + + // on vide le MA + vide (); + // on initialise la variable aleatoire + if (num_graphe != 0) + srand (num_graphe); + + // on ajoute les Ètats + for (i = 0; i < nb_etats; ++i) + { + addState(i,0,0); + } + + // on ajoute les lettres + for (i = 0; i < nb_lettres; i++) + { + addLettre (); + } + + for (i=0 ; i< nb_init ; ++i) + { + iota[rand()%nb_etats]=random(min_trans,max_trans); + } + + for (i=0 ; i max_tau) { + cerr << "MA::renormalize_state : "; + cerr << "min_tau > max_tau" << endl; + throw ERR_INPUT; + } + if (min > max) { + cerr << "MA::renormalize_state : "; + cerr << "min > max" << endl; + throw ERR_INPUT; + } + + Graph::iterator r; + LettreSFunc::iterator a; + SFunc::iterator s; + float sum, x; + bool taumodif=true; + sum=tau[q]; + r=phi.find(q); + if (r != phi.end()) { + for (a=r->second.begin() ; a != r->second.end() ; a++) { + for (s=a->second.begin() ; s!=a->second.end() ; s++) { + sum+=s->second; + } + } + } + bool good=false; + StateSet BadStates; + while ( !good ) { + good=true; + x=normalization/sum; + if (tau[q]*x > max_tau) { + tau[q]=max_tau; + if (taumodif) { + taumodif=false; + good=false; + } + } else if (tau[q]*x < min_tau) { + tau[q]=min_tau; + if (taumodif) { + taumodif=false; + good=false; + } + } else { + tau[q]=x*tau[q]; + } + sum=tau[q]; + if (r != phi.end()) { + for (a=r->second.begin() ; a != r->second.end() ; a++) { + for (s=a->second.begin() ; s!=a->second.end() ; s++) { + if (x*s->second > max) { + s->second = max; + if (BadStates.find(s->first) == BadStates.end()) { + BadStates.insert(s->first); + good=false; + } + } + else if (x*s->second < min) { + s->second=min; + if (BadStates.find(s->first) == BadStates.end()) { + BadStates.insert(s->first); + good=false; + } + } + else { + s->second=x*s->second; + } + } + } + } + } + return VAL(0); +} + +// Cree un MA aleatoire avec le maximum de controle +// nb_etats : number of states of the MA +// nb_lettres : number of letters of the alphabet of the MA +// num_graphe : if different of 0, the same number gives always the same MA +// max_nb_init : the maximal number of initial states +// max_nb_succ : the maximal number of successors by states-letter +// max_nb_term : the maximal number of terminal states +// min_trans : minimal value of transitions +// max_trans : maximal value of transitions +// min_iota : minimal value for iota(q) +// max_iota : maximal value for iota(q) +// min_tau : minimal value for tau(q) +// max_tau : maximal value for tau(q) +// nomalize : if different of 0, normalize sum of iota and sum of tau + successor transitions +RESULT MA::becomeRandomControl (const int nb_etats, + const int nb_lettres, + const int num_graphe, + const int max_nb_succ, + const int max_nb_init, + const int max_nb_term, + const float min_trans, + const float max_trans, + const float min_iota, + const float max_iota, + const float min_tau, + const float max_tau, + const float normalization, + const float prob_init, + const float prob_trans, + const float prob_term) +{ + + int i; + StateSet::const_iterator q, s; + SFunc::iterator r; + Alphabet::const_iterator a; + + const int ERR_INPUT=-1023; + if (min_iota > max_iota) { + cerr << "min_iota > max_iota !!!" << endl; + throw ERR_INPUT; + } + if (min_trans > max_trans) { + cerr << "min_trans > max_trans !!!" << endl; + throw ERR_INPUT; + } + if (min_tau > max_tau) { + cerr << "min_tau > max_tau !!!" << endl; + throw ERR_INPUT; + } + + // on vide le MA + vide (); + // on initialise la variable aleatoire + if (num_graphe != 0) + srand (num_graphe); + + // on ajoute les Ètats + for (i = 0; i < nb_etats; i++) + { + addState(i,0,0); + } + + // on ajoute les lettres + for (i = 0; i < nb_lettres; i++) { + addLettre (); + } + + /// --- iota --- + i=0; + for (i=0 ; isecond; + } + float x; + bool good=false; + StateSet BadStates; + while ( !good ) { + x=normalization/sum; + good=true; + for (r=iota.begin() ; r != iota.end() ; r++) { + if (x * r->second > max_iota) { + sum+=r->second=max_iota; + if (BadStates.find(r->first) == BadStates.end()) { + BadStates.insert(r->first); + good=false; + } + } + else if (x * r->second < min_iota) { + sum+=r->second=min_iota; + if (BadStates.find(r->first) == BadStates.end()) { + BadStates.insert(r->first); + good=false; + } + } + else { + sum+=r->second = x*r->second; + } + } + } + } + + /// --- Tau + Transitions --- + i=0; + for (i=0 ; isecond>0?q->second:-q->second; + } + sum = 1/sum; + for (q=V.begin() ; q != V.end() ; q++) { + q->second *= sum; + if (q->second == 0) { + V.erase(q); + } + } + // // Affichage de debogage + // cout << "\tMA::normaliseVecteur\n"; + // for (q=V.begin() ; q != V.end() ; q++) { + // cout << "\tV[" << q->first << "]=" << q->second << endl; + // } + // cout << "\t---\n"; +} + + +// genere un mot en fonction du modèle. En particulier, il faut récupérer +// la valeur des P_q(\Se) pour tous les états q. +// Description de l'algorithme : +// Soit r un langage rationnel, on construit P_r de la façon suivante ; +// Neg(u)=\sum_{x \in \Sigma}r(ux\Se)<0?r(ux\Se):0 + r(u)<0?r(u):0 +// P_r(ux\Se) = r(ux\Se)/Neg(u) si r(a\Se)>0 et 0 sinon +// P_r(\eps) = r(\eps)/Neg(u) + +RESULT MA::genere_mot(Word &w, const bool safe){ + // Dans un premier temps, on rÈcupËre les valeurs des + // P_q(\Se) + SFunc PSe; // contiendra la valeur des P_q(\Se) + + if (val_PSe(PSe) != VAL(0)) { + if ( safe ) { + return ERR(0); + } + } + + // on a w donnÈ, on calcule P(w), P(wx\Se) pour tout x et on conserve + // les w^-1P(\eps) et w^-1P(x\Se) positifs + w=""; // le mot courant initialisÈ ‡ epsilon + Lettre c; // la lettre courante + bool termine=false; + double Negw, Posw; + Alphabet::const_iterator x; + SFunc V, Vtmp; + SFunc::const_iterator q; + LettreSFunc::const_iterator a; + SFunc::const_iterator s; + Graph::const_iterator r; + map px; // va contenir px[0] = P(w), px[1] = P(wx_1\Se), ... , px[n] = P(wx_n\Se) + map::const_iterator l; + bool lettreTrouve; + double val; + double sum; + + V = iota; + + while (!termine) { + // normaliser le vecteur V, fait en sorte de mettre + // la somme de ses valeurs ‡ 1 et supprimes les entrÈes + // nulles (qui sont inutiles) + normaliseVecteur(V); + Negw=0; Posw=0; + // calcul de w^-1P(\eps) + px[0] = 0; + for (q = V.begin() ; q != V.end() ; q++) { + px[0]+= q->second * val_tau(q->first); + } + // on met ‡ jour Neg(w) et Pos(w) + if (px[0] < 0) + Negw += px[0]; + else + Posw += px[0]; + + // // AFFICHAGE DEBUG + // cout << "px[.]:" << endl; + // for (l=px.begin() ; l != px.end() ; l++) { + // cout << "px["; + // cout << l->first==0?'0':l->first; + // cout << "]="; + // cout << l->second << endl; + // } + // cout << "Negw=" << Negw << ", Posw=" << Posw << endl; + // cout << " -- px[.]" << endl; + // // END AFFICHAGE DEBUG + + // initialisation de px + for (x=Sigma.begin() ; x != Sigma.end() ; x++) + px[*x]=0; + // calcul de w^-1P(x\Se) + for (q = V.begin() ; q != V.end() ; q++) { + r=phi.find(q->first); + if (r != phi.end()) { + for (a=r->second.begin() ; a != r->second.end() ; a++) { + for (s=a->second.begin() ; s != a->second.end() ; s++) { + // // AFFICHAGE DEBUG + // cout << "\t\t**********" << endl; + // cout << "q->first=" << q->first << endl; + // cout << "q->second=" << q->second << endl; + // cout << "r->first=" << r->first << endl; + // cout << "a->first=" << a->first << endl; + // cout << "s->first=" << s->first << endl; + // cout << "s->second=" << s->second << endl; + // cout << "PSe[s->first]=" << PSe[s->first] << endl; + // cout << "\t\t**********" << endl; + // // FIN AFFICHAGE DEBUG + px[a->first] += q->second * s->second * PSe[s->first]; + } + } + } + } + for (x=Sigma.begin() ; x != Sigma.end() ; x++) { + // mise ‡ jour de Neg(w) et Pos(w) + if (px[*x] < 0) + Negw += px[*x]; + else + Posw += px[*x]; + } + + // // AFFICHAGE DEBUG + // cout << "px[.]: " << endl; + // for (l=px.begin() ; l != px.end() ; l++) { + // cout << "px["; + // cout << l->first==0?'0':l->first ; + // cout << "]="; + // cout << l->second ; + // cout << endl; + // } + // cout << "Negw=" << Negw << ", Posw=" << Posw << endl; + // cout << " -- px[.]" << endl; + // // END AFFICHAGE DEBUG + + // on a fini de calculer les valeurs possibles. On choisit seulement + // parmis les valeurs positives + if (Posw == 0) { + cerr << "ERREUR !!! MA::genere_mot" << endl; + cerr << "prefixe = "; + cerr << affiche(w) << endl; + cerr << "Impossible d'utiliser cette methode avec ce prefixe dans ce MA" << endl; + cerr << "Pos(\\epsilon)=0 !!!" << endl; + throw ERR(21); + } + val = random(0,Posw); + sum = 0; + lettreTrouve=false; + for (l=px.begin() ; l != px.end() && !lettreTrouve ; l++) { + // // AFFICHAGE DE DEBUG + // cout << "\tval=" << val; + // cout << ", sum=" << sum; + // cout << ", Posw=" << Posw; + // cout << ", Negw=" << Negw; + // cout << "\tpx["; + // cout << l->first==0?'0':l->first; + // cout << "]="; + // cout << l->second << endl; + // // AFFICHAGE DE DEBUG + if (l->second > 0) { + sum+= l->second; + if (sum >= val) { + if (l->first != 0) { + c = l->first; + w += c; + // // AFFICHAGE DEBUG + // cout << "c="; + // cout << c; + // cout << ", w=" ; + // cout << affiche(w); + // cout << endl; + // // AFFICHAGE DEBUG + } + else { + termine=true; + // // AFFICHAGE DEBUG + // cout << "termine" << endl ; + // // AFFICHAGE DEBUG + } + lettreTrouve=true; + } + } + } + + if (!termine) { + Vtmp.clear(); + // Mise ‡ jour du vecteur d'initialisation + for (q=V.begin() ; q != V.end() ; q++) { + r=phi.find(q->first); + if (r != phi.end()) { + a = r->second.find(c); + if (a != r->second.end()) { + for (s=a->second.begin() ; s != a->second.end() ; s++) { + Vtmp[s->first] += q->second * s->second; + } + } + } + } + V = Vtmp; + } + } + return VAL(0); +} + +// genere un Èchantillon de mots +RESULT MA::genere_echantillon ( int taille, + Sample & S, + const int num_echantillon) +{ + int i; + Word w; + if (num_echantillon != 0) + { + srand (num_echantillon); + } + + S = Sample (Sigma, alph, false); + for (i = 0; i < taille; i++) + { + genere_mot (w, false); + S.insert (w); + } + return VAL (0); +} + +// genere un Èchantillon de mots : l'echantillon reste identique si lot est identique +RESULT MA::genere_echantillon (const int taille, + Sample & S, + const char *Filename, + const int num_echantillon) +{ + if (PFA_DEBUG) + { + if (Filename == NULL) + { + cerr << " PFA::echantillon(int taille, char *Filename) : Filename = NULL !!!" << endl; + } + } + genere_echantillon (taille, S, num_echantillon); + return S.save (Filename); +} + + +// Calcule les valeurs de P_q(\S_e) pour +// tous les Ètats q +RESULT MA::val_PSe(SFunc &PSe) const { + Simplex simplex; + StateSet::const_iterator q,r; + Alphabet::const_iterator a; + int j; + float tmp; + + simplex.set_number_of_unknown_to(Q.size()); + + for (q=Q.begin() ; q != Q.end() ; q++) { + simplex.setval(-val_tau(*q)); + for (r=Q.begin(), j=1 ; r != Q.end() ; r++, j++) { + if (*r == *q) { + tmp=-1; + } + else { + tmp=0; + } + for (a=Sigma.begin() ; a != Sigma.end() ; a++) { + tmp += val_phi(*q,*a,*r); + } + simplex.setparam(j,tmp); + } + simplex.add_equality_constraint(); + } + + simplex.set_mode(realNotBounded); // on utilise des réels pouvant êtres négatifs + + float epsilon; + if (! simplex.has_solution(PSe,epsilon) ) { + PSe.clear(); + simplex.affiche(); + cerr << "ERREUR INEXPLICABLE !!!!\n"; + cerr << "Le système d'équation doit être mal posé !\n"; + throw ERR(0); + } else { + return VAL(0); + } +} + +/// --------------------- Testeurs ------------------------------ + +// Teste la cohÈrence de la structure de donnÈe. +bool MA::coherent (void) const +{ + bool + res = true; + // on cherche une transition contenant un Ètat n'appartenant pas + // ‡ l'ensemble des Ètats. + Graph::const_iterator q; + LettreSFunc::const_iterator a; + SFunc::const_iterator s; + for (q = phi.begin (); q != phi.end (); ++q) + { + for (a = q->second.begin (); a != q->second.end (); ++a) + { + for (s = a->second.begin (); s != a->second.end (); ++s) + { + if ( (Q.find(q->first) == Q.end ()) + || (Q.find (s->first) == Q.end ())) + { + res = false; + if (PFA_VERBOSE) + { + cerr << "Erreur de coherence (phi) : ("; + cerr << q->first << "," << a->first << ","; + cerr << s->first << ") = " << s->second << " !!! " << endl; + } + } + } + } + } + return res; +} + +// Teste si le MA est coherent et est un SPFA. valeur de iota, tau et phi dans [0,1] +bool MA::isSPFA (void) const +{ + + if (!coherent ()) + { // si le ffa n'est pas coherent + return false; + } + // si le ffa est coherent + // Test de iota + SFunc::const_iterator s; + float sum = 0; + // cerr.precision(30); + for (s = iota.begin (); s != iota.end (); ++s) + { + if ((s->second < 0) || (s->second > 1)) + { + //~ cerr << "iota " << s->first << "<0 ou >1 !!! : " << s->second << endl; + return false; + } + sum += s->second; + } + if (!simeqone (sum)) + { + return false; + } + //cerr << "iota OK" << endl; + + // Test de tau + for (s = tau.begin (); s != tau.end (); ++s) + { + if ((s->second < 0) || (s->second > 1)) + { + //~ cerr << "tau " << s->first << "<0 ou >1 : " << s->second << endl; + return false; + } + } + + // Test of phi and + // of the property : \forall q \in Q and \forall a \in \Sigma + // tau(q) + \sum_{s\in Q} phi(q,a,s)=1 + Graph::const_iterator q; + LettreSFunc::const_iterator a; + for (q = phi.begin (); q != phi.end (); ++q) + { + sum = val_tau (q->first); + for (a = q->second.begin (); a != q->second.end (); ++a) + { + for (s = a->second.begin (); s != a->second.end (); ++s) + { + if ((s->second < 0) || (s->second > 1)) + { + //~ cerr << "phi(" << q->first << ","; + //~ cerr << a->first << ","; + //~ cerr << s->first << ")="; + //~ cerr << s->second << " FALSE !!!" << endl; + return false; + } + //cerr << "phi(" << q->first << "," << a->first << "," << s->first << ")=" << s->second << endl; + //cerr << "sum = " << sum << endl; + sum += s->second; + } + } + if (!simeqone (sum)) + { + //cerr << "phi(" << q->first << ",*,*)=" << sum << " FALSE !!!" << endl; + return false; + } + } + // on a passÈ toutes les Èpreuves + return true; +} + +// Fonction qui rend le MA vide (pas d'Ètats pas de lettre) +void +MA::vide () +{ + name.clear (); + Q.clear (); + Sigma.clear (); + iota.clear (); + tau.clear (); + phi.clear (); + alph.clear (); +} + +// renvoi vrai si le MA est un PFA +bool MA::isPFA () const +{ + if (!isSPFA ()) + return false; + + // --- Explication de l'algorithme ------ + // On fait un parcour en profondeur en notant tous les Ètats atteint en partant + // des sources (les Ètats initiaux) + // Puis on inverse le graphe et on refait un parcours en profondeur en partant + // des Ètats terminaux. + // Si l'ensemble des Ètats atteint par les Ètats terminaux dans le graphe + // inverse contient l'ensemble des Ètats atteint en partant des Ètats initiaux + // alors le SPFA considÈrÈ est un PFA. + // --- Fin de l'explication de l'algorithme --- + + // d'abord le parcours inverse + // 1 - On crÈe le graphe inverse + Graph + Inv; + Graph::const_iterator q; + LettreSFunc::const_iterator a; + SFunc::const_iterator s, r; + StateSet + Qir, + Q2, + W; + State + etat_cour; + + // On inverse le graphe Inv(r,a,q) = phi (q,a,r) + + for (q = phi.begin (); q != phi.end (); q++) + { + for (a = (q->second).begin (); a != (q->second).end (); a++) + { + for (s = (a->second).begin (); + s != (a->second).end (); s++) + { + Inv[s->first][a->first][q->first] = s->second; + } + } + } + + // Pour chaque Ètat terminal, on regarde l'ensemble des Ètats que + // l'on atteint + for (r = tau.begin (); r != tau.end (); r++) + { + W.insert (r->first); + Qir.insert (r->first); + } + + while (!W.empty ()) + { + etat_cour = *(W.begin ()); + W.erase (W.begin ()); + q = Inv.find (etat_cour); + if (q != Inv.end ()) + { + for (a = (q->second).begin (); + a != (q->second).end (); a++) + { + for (s = (a->second).begin (); + s != (a->second).end (); s++) + { + if (Qir.find (s->first) == Qir.end ()) + { + Qir.insert (s->first); + W.insert (s->first); + } + } + } + } + } + + // Pour chaque Ètat initial on regarde si on tombe bien dans + // l'ensemble des Ètats qui atteignent un Ètat terminal. + for (r = iota.begin (); r != iota.end (); ++r) + { + W.insert (r->first); + Q2.insert (r->first); + } + + while (!W.empty ()) + { + etat_cour = *W.begin (); + W.erase (W.begin ()); + q = phi.find (etat_cour); + if (q != phi.end ()) + { + for (a = (q->second).begin (); + a != (q->second).end (); ++a) + { + for (s = (a->second).begin (); + s != (a->second).end (); ++s) + { + if (Q2.find (a->first) == Q2.end ()) + { + Q2.insert (a->first); + W.insert (a->first); + } + if (Qir.find (s->first) == Qir.end ()) + { + return false; + } + } + } + } + } + return true; +} + + +string MA::affiche (const Word & w) const +{ + Word::const_iterator a; + string res; + Dictionnaire::const_iterator x; + for (a = w.begin() ; a != w.end () ; ++a) + { + x=alph.find(*a); + if (x == alph.end()) { + res = "Dictionnaire ERROR "; + res += *a; + return res; + } + res += x->second; + res += ' '; + } + return res; +} + +void MA::next (Word & w) const +{ + Word::reverse_iterator ll; // last letter + Word::iterator z; + Lettre a; + Lettre first = *Sigma.begin (); + int i; + int level = w.size (); + bool end = false; + while ((w.size () > 0) && (!end)) + { + ll = w.rbegin (); + a = *ll; + ++a; + if (Sigma.find (a) != Sigma.end ()) + { + ++(*ll); + end = true; + } + else + { + z=w.end(); + --z; + w.erase(z); // w.pop_back (); + } + } + if (!end) + ++level; + for (i = w.size (); i < level; ++i) + { + w += first; // w.push_back (first); + } + +} + + +// erase the state badstate and all transitions from and to it +RESULT MA::erase (State badstate) +{ + Graph::iterator q, qtmp; + LettreSFunc::iterator a, atmp; + SFunc::iterator s, stmp; + StateSet::iterator r; + + // Suppression dans l'ensemble d'Ètats + r=Q.find (badstate); + if ( r == Q.end () ) + { + cerr << "MA::erase (State badstate) : demande de suppression d'un etat inexistant" << endl; + exit (-1); + } + Q.erase (r); + // Suppression dans iota + s = iota.find(badstate); + if (s != iota.end ()) + iota.erase (s); + // Suppression dans tau + s = tau.find(badstate); + if (s != tau.end ()) + tau.erase (s); + // Suppression dans phi + if (phi.find (badstate) != phi.end ()) + phi.erase (phi.find (badstate)); + + for (q = phi.begin (); q != phi.end ();) + { + for (a = q->second.begin (); a != q->second.end ();) + { + for (s = a->second.begin (); s != a->second.end ();) + { + if (s->first == badstate) + { + stmp = s; + ++stmp; + a->second.erase (s); + s = stmp; + } + else + ++s; + } + if (a->second.empty ()) + { + atmp = a; + ++atmp; + q->second.erase (a); + a = atmp; + } + else + ++a; + } + if (q->second.empty ()) + { + qtmp = q; + ++qtmp; + phi.erase (q); + q = qtmp; + } + else + ++q; + } + + return VAL (0); +} + +StateSet MA::delta (const State q, const Word &w) const +{ + StateSet R; + R.insert(q); + return delta(R,w); +} + +StateSet MA::delta (const StateSet &R, const Word &w) const +{ + StateSet V; // le vecteur correspondant aux Ètats atteints + StateSet X; // un vecteur temporaire + StateSet::iterator xi; + Graph::const_iterator q; + LettreSFunc::const_iterator b; + SFunc::const_iterator r; + Word::const_iterator a; + + //~ cout << endl; + V=R; + for (a=w.begin() ;a != w.end() ; a++) + { + X.clear(); + for (xi=V.begin() ; xi != V.end() ; ++xi) + { + q=phi.find(*xi); + if (q != phi.end()) + { + b=q->second.find(*a); + if (b != q->second.end()) + { + for (r = b->second.begin() ; r != b->second.end() ; ++r) + { + X.insert(r->first); + } + } + } + } + V=X; + } + return V; +} + + +void MA::allTransitions(TransitionFunction &T) const { + T.clear(); + Graph::const_iterator q; + LettreSFunc::const_iterator a; + SFunc::const_iterator r; + Transition t; + for (q=phi.begin() ; q != phi.end() ; ++q) { + t.qdep= q->first; + for (a=q->second.begin() ; a!=q->second.end() ; ++a) { + t.a=a->first; + for (r=a->second.begin() ; r != a->second.end() ; ++r) { + t.qarr=r->first; + T[t]=0; + } + } + } +} + +void MA::allStates(SFunc &S) const { + StateSet::const_iterator q; + S.clear(); + for (q=Q.begin() ; q!=Q.end() ;++q) { + S[*q]=0; + } +} + +// Become the MA with maximum number of transitions +RESULT MA::becomeComplete (const int nb_etats, const int nb_lettres) { + clear(); + float valinit = 1/ float(nb_etats); + float val = 1/float(nb_etats + 1); + int i; + + for (i=0 ; i + +// affiche un mot +string affiche (const Word & w, const Dictionnaire & alph); +// La fonction qui va charger les info à partir d'un fichier +RESULT charge (char *nomFic); +// initialisation des arguments (ligne de commande) +int initialise_arguments (int argc, char *argv[]); +// La procédure qui initialise le random +int randomize (void); +int affiche_utilisation (void); +int affiche_options (void); +RESULT export_to_pdf (const MA & A, + const string & fic_ps, + const string & fic_tmp, + const int precision = 3, + const bool noms_etats = false, + const bool multiples_trans = false); +void show_ps (string & fic_ps); +// Affiche toutes les distances entre A et B +void affiche_distance (PFA & A, const PFA & B, const int taille_ech_test, + const string & flag); +void affiche_distance (PFA & A, const PFA & B, const int taille_ech, + const char *flag); +void affiche_classe (PFA & A); +// --- La procedure pour debbugger --- + +float fonction (float val, float moy, float ecart); +// La procedure principale +int main (int argc, char *argv[]); +#endif diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..ca1f36e --- /dev/null +++ b/main.cpp @@ -0,0 +1,1324 @@ +/*************************************************************************** + main.C - description + ------------------- + begin : mer oct 9 19:14:09 CEST 2002 + copyright : (C) 2002 by Yann Esposito + email : esposito@cmi.univ-mrs.fr +***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +using namespace std; +#include "interface.H" +#include "test.H" +#include "main.H" + +// #define MAXFLOAT 3.40282347e+38F + +/// ########################################################################## /// +// --- Les variables globales d'entrées qui parametre l'expérimentation + +// Les fichier + +string temporary_directory= "/tmp/dees/"; // le répertoire temporaire + +string ficffaA = temporary_directory + "A"; // Fichier du ffa A +string ficffaB = temporary_directory + "B"; // Fichier du ffa B +string ficdotA = temporary_directory + "A.dot"; // Le fichier dot associé à A +string ficdotB = temporary_directory + "B.dot"; // Le fichier dot associé à B +string ficech = temporary_directory + "A.ech"; // Le fichier échantillon généré par A +string ficechpre = temporary_directory + "A.ecp"; // Le fichier échantillon préfixe généré par A +string ficpsA = temporary_directory + "A.ps"; // La fichier de visualisation de A +string ficpsB = temporary_directory + "B.ps"; // Le fichier de visualisation de B + +// Les Èchantillons +Sample S; // main sample +Sample Stest; // test sample +int num_ech = 0; // Le numero de l'Èchantillon +int num_ech_test = 1; // Le numbero de l'Èchantillon test +int taille_ech = 1000; // La taille de l'Èchantillon +int taille_ech_test = 1000; // La taille de l'Èchantillon test + +// Le PFA alÈatoire +int numPFA = 0; // Le numero du PFA gÈnÈrÈ +int nb_etats = 5; // Le nombre d'Ètats du PFA gÈnÈrÈ +int nb_lettres = 2; // Le nombre de lettres du PFA gÈnÈrÈ + +// Les prÈcisions +double precision = 0.5; // la prÈcision (0 -> prefix tree, 1 -> single state) +double precpow = -1; // La prÈcision en mode exponentiel +double epsprime = 0; // La valeur de suppression des transitions (0 delete nothing, 1 delete all) +unsigned int seuil = 0; // le seuil en dessous duquel un prefixe n'est plus pris en compte dans l'apprentissage +double seuilbm = .0001 ; // Le seuil pour le test de convergence de BM +unsigned int maxmots = INT_MAX; // le nombre maximal de mots à ajouter à l'ensemble de test à chaque étapes + +// L'affichage +string nom_A = "A"; // le nom du PFA A +string nom_B = "B"; // le nom du PFA B +bool affiche_A = true; // affiche l'automate source ou non +bool affiche_B = true; // affiche l'automate destination +bool verbose = false; // mode verbose pour le test +bool affiche_etats = false; // affiche les Ètats dans le .dot +int viewprec=3; // precision des parametres a l'affichage +bool viewstates=false; // on met le numero des etats +bool viewmultipletransitions=false; // vrai pour ne plus regrouper les transitions +bool interactive=false; // interactive mode + +// L'apprentissage +T_ModeReturn moderet = end; // Le mode de retour des arÃtes (end ou begin) +T_ModeEpsilon modeeps = variable; // Le mode d'apprentissage avec epsilon fixe ou variable (epsfixed ou variable) +float test_proportion = 0.2; // la proportion de l'echantillon attribuee au test +int nb_tours = 100; // Le nombre d'itÈrations pour Baum Welch +int nb_essais = 10; // le nombre d'essais pour le best learning +int max_states = INT_MAX; // le nombre maximal d'etats pour DEES +bool stepssave = false; // vrai si on veut enregistrer toutes les étapes de l'apprentissage. + +// L'exportation de fichier +string format = "ffa"; + +// les distances +bool smooth = false; + +string cmd; +PPRFA A; +PPRFA B; + +stringstream convert; // variable qui permet de convertir les stream en entiers ou flottants + +/// ########################################################################## /// + + +// affiche un mot +string +affiche (const Word & w, const Dictionnaire & alph) +{ + Word::const_iterator a; + string res; + for (a = w.begin (); a != w.end (); ++a) + { + res += alph.find (*a)->second; + res += ' '; + } + return res; +} + + +void show(MA A) { + string dotfile; + string pdffile; + stringstream trad; + trad << temporary_directory << "pfa"<< int(time(NULL)); + trad >> pdffile; + dotfile=pdffile; + pdffile += ".pdf"; + dotfile += ".dot"; + A.save_dot(dotfile, viewprec, viewstates, viewmultipletransitions); + string cmd; + cmd += "dot -Tepdf "; + cmd += dotfile; + cmd += ">"; + cmd += pdffile; + system(cmd.c_str()); + show_ps(pdffile); +} + + + +// La procÈdure qui initialise le random +int +randomize (void) +{ + // mise a jour du random + unsigned int i = 0; + char c; + ifstream dev_rnd ("/dev/urandom"); + if (dev_rnd != NULL) + { + for (int k = 0; k < 4; k++) + { + dev_rnd.get (c); + i = i << 8 | c; + } + srand (i); + return i; + } + else + { + srand (num_ech); + return num_ech; + } +} + +int +affiche_utilisation (void) +{ + string fichelp = "./help/"; + fichelp += "help.txt"; + ifstream fh (fichelp.c_str ()); + if (fh == NULL) + { + cout << "DEES : "; + cout << "WARNING: " << fichelp << " not found." << endl; + } + else + { + cout << fh.rdbuf (); + fh.close (); + cout << endl; + } + return 0; +} + +int +affiche_options (void) +{ + string fichelp = "/Users/esposito/dees/help/"; + fichelp += "/help_options.txt"; + ifstream fh (fichelp.c_str ()); + if (fh == NULL) + { + cout << "DEES : "; + cout << "WARNING: " << fichelp << " not found." << endl; + } + else + { + cout << fh.rdbuf (); + fh.close (); + cout << endl; + } + return 0; +} + + +RESULT +export_to_pdf (const MA & A, + const string & fic_pdf, + const string & fic_tmp, + const int precision, + const bool noms_etats, + const bool multiples_trans) +{ + A.save_dot (fic_tmp, precision, noms_etats, multiples_trans); // On l'enregistre dans un fichier dot + // on Ècrit la commande + string cmd; + cmd = "dot -Tepdf "; + cmd += fic_tmp; + cmd += " > "; + cmd += fic_pdf; + + // on execute la transformation + system (cmd.c_str ()); + return 0; +} + +void +show_ps (string & fic_pdf) +{ + string cmd; + cmd += "open "; + cmd += fic_pdf; + cmd += "&"; + system (cmd.c_str ()); +} + + +// Affiche toutes les distances entre A et B +void +affiche_distance (PFA & A, const PFA & B, const int taille_ech_test, + const string & flag) +{ + double pA, pB; + A.genere_echantillon (taille_ech_test, S, num_ech_test); + cerr << "Test_Sample_size\t"; + cerr << "precision\t"; + cerr << "perplex A\t"; + cerr << "perplex B\t"; + cerr << "KL div\t"; + cerr << "d_2\t"; + cerr << "L_1\t"; + cerr << "d_2(nlog)\t"; + cerr << "L_1(nlog)\t"; + cout << taille_ech_test << "\t"; + cout << precision << "\t"; + cout << (pA = A.perplexite (S)) << "\t"; + cout << (pB = B.perplexite (S)) << "\t"; + cout << pB - pA << "\t"; + cout << A.d_2 (B, S) << "\t"; + cout << A.L_1 (B, S) << "\t"; + cout << A.d_2nlog (B, S) << "\t"; + cout << A.L_1nlog (B, S) << "\t"; + cout << flag << endl; +} + +void +affiche_distance (PFA & A, const PFA & B, const int taille_ech, + const char *flag) +{ + string s_flag = flag; + affiche_distance (A, B, taille_ech, s_flag); +} + +void +affiche_classe (PFA & A) +{ + if (!A.coherent ()) + { + cout << "uncoherent MA" << endl; + } + else if (!A.isSPFA ()) + { + cout << "MA" << endl; + } + else if (!A.isPFA ()) + { + cout << "SPFA" << endl; + } + else if (!A.isPRFA ()) + { + cout << "PFA" << endl; + } + else if (!A.isPDFA ()) + { + cout << "PRFA" << endl; + } + else + { + cout << "PDFA" << endl; + } +} + + +// Crossed validation learning +// Apprentissage avec validation croisÈe + +void Alergia(PFA &A, float prec, string ficsample, bool verbose) { + stringstream AL; + string ficsampletmp=temporary_directory + "tmpsample.alergia"; + Sample S; + S.load(ficsample); + S.save(ficsampletmp, alergia); + AL << "alergia"; + AL << " -a " << prec; + AL << " -o " << ficffaA; + AL << " -f " << ficsampletmp; + if (verbose) { + cout << ":: " << AL.str() << endl; + } + system(AL.str().c_str()); + + stringstream MOD; + string fictmp=temporary_directory + "alergia.tmp"; + MOD << "echo %Alergia > " << fictmp; + MOD << " && cat " << ficffaA << " >> " << fictmp; + if (verbose) { + cout << "transformation de l'automate avec :\n"; + cout << MOD.str() << endl; + } + system(MOD.str().c_str()); // on ajoute %Alergia au dÈbut du fichier + + if (verbose) { + cout << "on charge le fichier : " << fictmp << endl; + } + + A.load(fictmp); +} + +void MDI(PFA &A, float prec, string ficsample, bool verbose) { + string ficsampletmp=temporary_directory + "tmpsample.mdi"; + Sample S; + S.load(ficsample); + S.save(ficsampletmp, mdi); + stringstream MDI; + MDI << "mdi"; + MDI << " -b"; + if (verbose) { + MDI << " -v"; + } + MDI << " -c " << prec / double(taille_ech); + MDI << " -o " << ficffaA; + MDI << " -i " << ficsampletmp; + if (verbose) { + cout << ":: " << MDI.str() << endl; + } + system(MDI.str().c_str()); + + stringstream MOD; + string fictmp=temporary_directory + "mdi.tmp"; + MOD << "echo %MDI > " << fictmp; + MOD << " && cat " << ficffaA << " >> " << fictmp; + + if (verbose) { + cout << "transformation de l'automate avec :\n"; + cout << MOD.str() << endl; + } + system(MOD.str().c_str()); // on ajoute %MDI au dÈbut du fichier + + if (verbose) { + cout << "on charge le fichier : " << fictmp << endl; + } + + A.load(fictmp); +} + +// --- La procedure pour debbugger --- +float fonction (float val, float moy, float ecart) +{ + float constante = 1/(ecart * sqrt(2 * 3.1415)); + return constante * exp(- ((val - moy)*(val - moy)) / ecart); +} + +void BaumWelch(PFA A, Sample S, int nb_turns, string output) { + TransitionFunction T; + SFunc Iota, Tau; + double val, oldval; + A.allTransitions(T); + A.allStates(Iota); + A.allStates(Tau); + oldval=A.Likelihood(S); + for (int i=0 ; i < nb_turns ; i++) { + A.BaumWelch(S,T,Iota,Tau,3,true); + val=A.Likelihood(S); + //if (abs(val-oldval)<.1) { + // break; + //} + oldval=val; + if (verbose) { + cout << "Likelihood: " << A.Likelihood(S) << "\n"; + } + } + cout << endl; + + A.erase_bad_states(); + A.save(output); +} + + +// génère un PA complet + +RESULT generate_complete_random_pfa(int argc, char **argv, int i) { + + if (argc < i + 2) { + cerr << "dees --grp nbstates nbletters file" << endl; + cerr << "generate a complete random automaton with 'nbstates' states\n"; + cerr << "'nbletters' letters and save it in file\n"; + cerr << "usefull option:\n"; + cerr << "--numPFA : the number of the ma by default random number is choosen.\n"; + return -1; + } + + int nbstates=atoi(argv[i++]); + int nbletters=atoi(argv[i++]); + string output=argv[i++]; + + int num_graphe=0; //cout << "num graphe: "; cin >> num_graphe; + float min_trans=0.01; //cout << "min_trans: "; cin >> min_trans; + float max_trans=1; //cout << "max_trans: "; cin >> max_trans; + float prob_init=1; //cout << "prob_init: "; cin >> prob_init; + float prob_trans=1; //cout << "prob_trans: "; cin >> prob_trans; + float prob_term=1; //cout << "prob_term: "; cin >> prob_term; + + if (verbose) { + cout << "num graphe: " << num_graphe << endl; + cout << "prob_trans: " << prob_trans << endl; + cout << "prob_init: " << prob_init << endl; + cout << "prob_term: " << prob_term << endl; + cout << "min_trans: " << min_trans << endl; + cout << "max_trans: " << max_trans << endl; + } + + A.becomeRandom (nbstates, nbletters, numPFA, prob_trans, prob_init, prob_term, min_trans, max_trans); + + return A.save (output); +} + +RESULT generate_random_pfa(int argc, char **argv, int i) { + if (argc < i+3) { + cerr << "dees --random nbstates nbletters file\n"; + cerr << "generate a random automaton of class 'class' with 'nbstates' states\n"; + cerr << "'nbletters' letters and save it in file\n"; + cerr << "usefull option:\n"; + cerr << "--numPFA : the number of the ma by default random number is choosen.\n"; + cerr << "--interactive : ask you to enter values\n"; + return -1; + } + int nbstates=atoi(argv[i++]); + int nbletters=atoi(argv[i++]); + string output=argv[i++]; + + int num_graphe=0; + int max_nb_succ=nbstates; + int max_nb_init=nbstates; + int max_nb_term=nbstates; + float min_trans=0; + float max_trans=1; + float min_iota=0; + float max_iota=1; + float min_tau=0; + float max_tau=1; + float normalization=1; + float prob_init=.3; + float prob_trans=.3; + float prob_term=.3; + + if (interactive) { + cout << "num graphe (0=random): "; cin >> num_graphe; + cout << "max_nb_succ (width of the graph): "; cin >> max_nb_succ; + cout << "max_nb_init: "; cin >> max_nb_init; + cout << "max_nb_term: "; cin >> max_nb_term; + cout << "min_trans (minimal value of a transition): "; cin >> min_trans; + cout << "max_trans (maximal value of a transition): "; cin >> max_trans; + cout << "min_iota (minimal initial value): "; cin >> min_iota; + cout << "max_iota (maximal initial value): "; cin >> max_iota; + cout << "min_tau (minimal terminaison value): "; cin >> min_tau; + cout << "max_tau (maximal terminaison value): "; cin >> max_tau; + cout << "normalization (value of normalisation mostly 1): "; cin >> normalization; + cout << "prob_init (probability for a state to be initial: "; cin >> prob_init; + cout << "prob_trans (probability for a terminaison to araise): "; cin >> prob_trans; + cout << "prob_term (probability for a state to be terminal): "; cin >> prob_term; + } + + A.becomeRandomControl (nbstates, nbletters, num_graphe, max_nb_succ, max_nb_init, max_nb_term, min_trans, max_trans, min_iota, max_iota, min_tau, max_tau, normalization, prob_init, prob_trans, prob_term); + + return A.save(output); +} + +RESULT show_sample_forward(int argc, char**argv, int i) { + if (argc < i+2) { + cerr << "usage : --forward PFA sample\n"; + cerr << "return a list of couple word and its probability for the PFA\n"; + throw 2; + } + A.load(argv[i++]); + S.load(argv[i++]); + if (A.dictionnaire() != S.dictionnaire()) { + cerr << "Alphabets of the PFA and of the sample differ !" << endl; + Dictionnaire D; + Dictionnaire::const_iterator x; + cerr << "dictionnaire of the PFA\n"; + D=A.dictionnaire(); + for (x=D.begin() ; x != D.end() ; x++) { + cout << x->first << ":" << x->second << "\n"; + } + + cerr << "dictionnaire of the Sample\n"; + D=S.dictionnaire(); + for (x=D.begin() ; x != D.end() ; x++) { + cout << x->first << ":" << x->second << "\n"; + } + throw 2; + } + Sample::const_iterator w; + double somme=0 ; + double logsomme = 0; + double val ; + for (w=S.begin() ; w != S.end() ; w++) { + cout << A.affiche(w->first) << " : "; + cout.flush(); + val = A.p_bar(w->first); + somme += val; + cout << val ; + val = A.plog_bar(w->first); + logsomme += val; + cout << ", log forward : " << val; + cout << ", exp(log forward) :" << exp(val); + cout << ", pBarDirect : " << A.p_bar_directe(w->first); + cout << endl; + } + cout << "sum = " << somme << ", somme de exp(log(forward)) : " << logsomme << endl; + return VAL(0); +} + + +RESULT show_sample_proba(int argc, char **argv, int i){ + if (argc < i+2) { + cerr << "usage : --proba PFA sample\n"; + cerr << "return a list of couple word and its probability for the PFA\n"; + throw 2; + } + A.load(argv[i++]); + S.load(argv[i++]); + if (A.dictionnaire() != S.dictionnaire()) { + cerr << "Alphabets of the PFA and of the sample differ !" << endl; + Dictionnaire D; + Dictionnaire::const_iterator x; + cerr << "dictionnaire of the PFA\n"; + D=A.dictionnaire(); + for (x=D.begin() ; x != D.end() ; x++) { + cout << x->first << ":" << x->second << "\n"; + } + + cerr << "dictionnaire of the Sample\n"; + D=S.dictionnaire(); + for (x=D.begin() ; x != D.end() ; x++) { + cout << x->first << ":" << x->second << "\n"; + } + throw 2; + } + Sample::const_iterator w; + double somme=0 ; + double logsomme = 0; + double val ; + for (w=S.begin() ; w != S.end() ; w++) { + cout << A.affiche(w->first) << " : "; + cout.flush(); + val = A.p_directe(w->first); + somme += val; + cout << val ; + val = A.plog(w->first); + logsomme += val; + cout << ", log p : " << val; + cout << ", exp(log p) :" << exp(val); + cout << endl; + } + cout << "sum = " << somme << ", somme de exp(log(p)) : " << logsomme << endl; + return VAL(0); +} + +void affiche_PSe(void) { + SFunc PSe; + SFunc::const_iterator q; + int res; + + res = A.val_PSe(PSe); + cout << "res = " << res << endl; + + for (q=PSe.begin() ; q != PSe.end() ; q++) { + cout << "P_" << q->first << "(\Se) = " << q-> second << endl; + } +} + + +/// ############################################################################# /// +/// ### INIT COMMAND LINE + MAIN #### /// +/// ############################################################################# /// + +// initialisation des arguments (ligne de commande) +int +initialise_arguments (int argc, char *argv[]) +{ + string arg; + int i = 1; + while ((i < argc) && (argv[i][0] == '-')) + { // pour chaque argument commenÃant par - + arg = argv[i]; + if ((arg == "-h") || (arg == "--help")) + { // affiche l'aide + throw 1; + } + // options muettes + else if ( + (arg == "--export") || // exporte vers des formats d'automates differents + (arg == "--convert") || // convertit des echantillons + (arg == "--dist") || // affiche la distance entre deux ffa + (arg == "--class") || // affiche la classe d'un pfa + (arg == "--sample") || // genere un Èchantillon + (arg == "--grp") || // genere un automate probabiliste + (arg == "--gcrp") || // genere un automate probabiliste complet + (arg == "--mdi") || // algorithme mdi + (arg == "--alergia") || // algorithme alergia + (arg == "--bm") || // algorithme Baum Welch + (arg == "--affiche") || // affiche un automate sur la sortie standard + (arg == "-H") || // affiche l'aide Ètendue (options) + (arg == "-Y" || arg == "-I") || // envoie la fonction Y (mode interactif) + (arg == "--test") || // fait un test ‡ partir de l'automate + (arg == "--random") || // generate a random automaton + (arg == "--proba") || // show probabilities of words of a sample + (arg == "--forward") || // show forward values of words of a sample + (arg == "--deletetransitions") || // delete transitions of some value + ((arg == "-P") || (arg == "--showps")) || // affichage postscript + (arg == "--PSe") // Affichage des valeurs de P(\Se) pour chaque état + + ) + { + } + else if ( + (arg == "--dees") || // algorithme dees (cible PRFA) + (arg == "--deesha") || // algorithme deesha (cible MA) + (arg == "--deesdet") ) // algorithme basé sur dees mais se limitant aux solution déterministes + { + precision=1; + } else if (arg == "--deesbm") // algorithme dees Baum Welch + { + precision=2; + } + else if ((arg == "--DEBUG") + || (arg == "-d") || (arg == "--debug")) + { + // PFA_DEBUG=true; + } + else if (arg == "--interactive") + { + interactive=true; + ++i; + } + else if (arg == "--format") + { + format = argv[++i]; + } + else if ((arg == "--VERBOSE") || (arg == "-v") || (arg == "--verbose")) + { + verbose = true; + // PFA_VERBOSE=true; + } + else if ((arg == "--MUTE") || (arg == "-m") || (arg == "--mute")) + { + // PFA_VERBOSE=false; + verbose = false; + } + else if ((arg == "--SAFE") || (arg == "--safe")) + { + // PFA_SAFE=true; + } + else if ((arg == "--UNSAFE") || (arg == "--unsafe")) + { + // PFA_SAFE=false; + } + else if ((arg == "--taille_ech") || (arg == "-te")) + { + convert << argv[++i]; + convert >> taille_ech; + } + else if (arg == "--maxmots") { + convert << argv[++i]; + convert >> maxmots; + } + else if (arg == "--num_ech") + { + num_ech = atoi (argv[++i]); + } + else if (arg == "--num_ech_test") + { + num_ech_test = atoi (argv[++i]); + } + else if ((arg == "--ficffaA") || (arg == "-i")) + { + ficffaA = argv[++i]; + } + else if (arg == "--ficffaB") + { + ficffaB = argv[++i]; + } + else if (arg == "-o") + { + ficffaA = ficech = ficffaB = ficdotB = ficpsB = argv[++i]; + } + else if (arg == "--moderet") + { + arg = argv[++i]; + if (arg == "begin") + moderet = begin; + else + moderet = end; + } + else if (arg == "--modeeps") + { + arg = argv[++i]; + if (arg == "fixed") + modeeps = epsfixed; + else if (arg == "variable") + modeeps = variable; + else + cerr << "option for --modeeps can be 'fixed' or 'variable', here it is '" << arg << endl; + } + else if (arg == "--ficdotA") + { + ficdotA = argv[++i]; + } + else if (arg == "--ficdotB") + { + ficdotB = argv[++i]; + } + else if (arg == "--ficech") + { + ficech = argv[++i]; + } + else if (arg == "--ficechpre") + { + ficechpre = argv[++i]; + } + else if ((arg == "--precision") || (arg == "-p")) + { + precision = atof (argv[++i]); + } + else if (arg == "--epsprime") + { + epsprime = atof (argv[++i]); + } + else if (arg == "--seuil") + { + seuil = atoi (argv[++i]); + } + else if (arg == "--numPFA") + { + numPFA = atoi (argv[++i]); + } + else if (arg == "--seuilbm") + { + seuilbm = atof (argv[++i]); + } + else if (arg == "--nb_tours") + { + nb_tours = atoi (argv[++i]); + } + else if (arg == "--ficps") + { + ficpsA = argv[++i]; + } + else if (arg == "--ficpsB") + { + ficpsB = argv[++i]; + } + else if (arg == "--stepssave") + { + stepssave=true ; + } + else if (arg == "--nb_etats") + { + nb_etats = atoi (argv[++i]); + } + else if (arg == "--nb_essais") { + nb_essais = atoi (argv[++i]); + } + else if (arg == "--max_states") { + max_states = atoi (argv[++i]); + } + else if (arg == "--nb_lettres") + { + nb_lettres = atoi (argv[++i]); + } + else if (arg == "--precpow") + { + precpow = atof (argv[++i]); + } + else if (arg == "--affiche_A") + { + affiche_A = true; + } + else if (arg == "--affiche_B") + { + affiche_B = true; + } + else if (arg == "--blind") + { + affiche_A = affiche_B = false; + } + else if ((arg == "--taille_ech_test") || (arg == "-tt")) + { + taille_ech_test = atoi (argv[++i]); + } + else if (arg == "--name") + { + nom_A = argv[++i]; + } + else if (arg == "--nom_B") + { + nom_B = argv[++i]; + } + else if (arg == "--test_proportion") + { + test_proportion = atof (argv[++i]); + } + else if (arg == "--smooth") { + smooth=true; + } + else if (arg == "--rand") { + srand( atoi(argv[++i]) ); + } + else if (arg == "--viewprec") { + viewprec=atoi(argv[++i]); + } + else if (arg == "--viewstates") { + viewstates=true; + } + else if (arg == "--viewmultipletransitions") { + viewmultipletransitions=true; + } + else + { + cerr << "unknow option : " << arg << endl; + } + i++; + } + return i; +} + +// La procedure principale +int +main (int argc, char *argv[]) +{ + int i = 0; + string commande; + commande = "mkdir " + temporary_directory + ">/dev/null 2>&1"; + system(commande.c_str()); + try + { + if (argc < 2) + throw 1; + randomize (); + i = initialise_arguments (argc, argv); + + string arg; + arg = argv[1]; + if (arg == "-h" || arg == "--help") + { // ---------- help --------------- + throw 1; + } + else if (arg == "-H") + { // ----------------- HELP with options ------- + affiche_utilisation (); + affiche_options (); + cout << "Report bugs or suggestions to Yann Esposito ." << endl; + } + else if ((arg == "-Y") || (arg == "-I")) + { // -------------- interactive mode ------------- + Y (); + } + else if (arg == "--test") + { + test(); + } + else if (arg == "--PSe") + { + ficffaA = argv[i]; + if (!OK(A.load(ficffaA))) { + throw string ("Erreur d'ouverture du fichier ") + ficffaA; + } + affiche_PSe(); + } + else if (arg == "--export") + { // ---------------- exportation---------------- + if (argc < i + 3) { + cerr << "export command export some automaton file to another format" << endl; + cerr << "available format are dot, pdf and ffa." << endl; + cerr << "usage: dees --export [OPTIONS] format input output" << endl; + throw 2; + } + format = argv[i]; + ficffaA = argv[i+1]; + ficffaB = argv[i + 2]; + if (!OK(A.load (ficffaA))) { + throw string ("Erreur d'ouverture du fichier ") + ficffaA; + } + A.name = nom_A; + if (format == "dot") + { // exportation to dot format + A.save_dot (ficffaB); + } + else if (format == "pdf") + { // exportation to ps format + export_to_pdf (A, ficffaB, temporary_directory + "tmp.dot"); + } + else if (format == "ffa") + { // exportation ffa + A.save (ficffaB); + } + else + { + cerr << "export command export some automaton file to another format" << endl; + cerr << "available format are dot, ps and ffa." << endl; + cerr << "usage: dees --export [OPTIONS] format input output" << endl; + throw 4; + } + } + else if (arg == "--affiche") + { // ------------------------ affichage ------------------- + if (argc < i + 1) { + cerr << "--affiche command show the automaton on standart output" << endl; + cerr << "usage: dees --affiche [OPTIONS] automaton" << endl; + throw 2; + } + A.load (argv[i]); + A.affiche (); + } + else if ((arg == "--showps") || (arg == "-P")) + { // --- affichage du postscript ------ + if (argc < i + 1) { + cerr << "showps or -P command show the automaton in gv" << endl; + cerr << "you must have dot (part of Graphviz project) and a script named open" << endl; + cerr << "which is a pdf viewer installed" << endl; + cerr << "usage: dees <--showps or -P> [OPTIONS] automaton" << endl; + cerr << "usefull option: --name name" << endl; + throw 2; // pas assez d'arguments + } + A.load (argv[i]); + A.name = nom_A; + show(A); + } + else if (arg == "--dist") + { // ----------------------- calcul des distances ------------ + if (argc < i + 2) { + cerr << "dist command show some distances between two automata." << endl; + cerr << "usage: dees --dist [OPTIONS] automaton_A automaton_B" << endl; + cerr << "usefull option: --taille_ech_test size" << endl; + cerr << " --smooth or --no_smooth" << endl; + throw 2; + } + A.load (argv[i]); + B.load (argv[i + 1]); + if (smooth == true) { + B.lisse (); + } + affiche_distance (A, B, taille_ech_test, ""); + } + else if (arg == "--deletetransitions") { + if (argc < i + 3) { + cerr << "dees --deletetransitions input_pfa output_pfa min max\n"; + cerr << "delete transitions of the input_pfa which values are between min and max\n"; + cerr << "renormalise and save it in output_pfa file.\n"; + return -1; + } + PFA A; + string input=argv[i++]; + string output=argv[i++]; + double min=atof(argv[i++]); + double max=atof(argv[i++]); + A.load(input); + if (max < min) { + double tmp = max; + max=min; + min=tmp; + cerr << "Warning max < min !" << endl; + } + A.erase_transitions(max,min); + A.rend_PFA(); + A.save(output); + } + else if (arg == "--sample") + { // --------------------- generation d'un echantillon --- + if (argc < i + 3) { + cerr << "sample command generate a sample from an automaton." << endl; + cerr << "usage: dees --sample [OPTIONS] automaton size sample" << endl; + cerr << "usefull options:" << endl; + cerr << "--format " << endl; + cerr << "--num_ech num_sample" << endl; + throw 2; + } + ficffaA = argv[i]; + taille_ech = atoi (argv[i + 1]); + ficech = argv[i + 2]; + A.load (ficffaA); + A.genere_echantillon (taille_ech, S, num_ech); + if (format == "ffa") + S.save (ficech, ffa); + else if (format == "alergia") + S.save (ficech, alergia); + else if (format == "mdi") + S.save (ficech, mdi); + else + throw 4; + } + else if (arg == "--mdi") { + if (argc > i) + { + ficech = argv[i]; + } + else + { + throw 1; + } + if (verbose) + cout << "loading " << ficech << "..." << endl; + + MDI(A,precision,ficech,verbose); + + if (verbose) + cout << "saving A in " << ficffaA << endl; + A.save (ficffaA); + // affichage de l'automate + if (affiche_A) + { + show(A); + } + } + else if (arg == "--alergia") { + if (argc <= i) + throw 1; + + ficech = argv[i]; + if (verbose) + cout << "loading " << ficech << "..." << endl; + + Alergia(A,precision,ficech,verbose); + + if (verbose) + cout << "saving A in " << ficffaA << endl; + + A.save (ficffaA); + // affichage de l'automate + if (affiche_A) + { + show(A); + } + } + else if (arg == "--deesdet") + { + + if (argc > i) + { + ficech = argv[i]; + } + else + { + cerr << "--dees command learn an automaton using dees." << endl; + cerr << "usage: dees --dees [OPTIONS] sample" << endl; + cerr << "usefull options:" << endl; + cerr << "-p or --precision float\tthe precision parameter" << endl; + cerr << "--epsprime float\tnumber under which a transition is deleted" << endl; + cerr << "-v or --verbose" << endl; + cerr << "--moderet [begin or end]" << endl; + cerr << "--max_states number" << endl; + cerr << "--seuil seuil" << endl; + cerr << "--stepssave\tsave steps of the algorithm" << endl; + throw 2; + } + if (verbose) + cout << "loading " << ficech << "..." << endl; + if (!OK (S.load (ficech.c_str ()))) + { + cerr << "impossible d'ouvrir " << ficech << endl; + throw 5; + } + + epsprime = precision*pow(double(S.size()),-0.25)/5; + epsprime = min(sqrt(precision),0.1); + + A.DEES (determinist, S, precision, epsprime, verbose, moderet, modeeps, max_states, seuil,10,0,true,stepssave); + if (verbose) + cout << "saving A in " << ficffaA << endl; + A.save (ficffaA); + // affichage de l'automate + if (affiche_A) + { + show(A); + } + } + else if (arg == "--dees") + { + + if (argc > i) + { + ficech = argv[i]; + } + else + { + cerr << "--dees command learn an automaton using dees." << endl; + cerr << "usage: dees --dees [OPTIONS] sample" << endl; + cerr << "usefull options:" << endl; + cerr << "-p or --precision float\tthe precision parameter" << endl; + cerr << "--epsprime float\tnumber under which a transition is deleted" << endl; + cerr << "-v or --verbose" << endl; + cerr << "--moderet [begin or end]" << endl; + cerr << "--max_states number" << endl; + cerr << "--seuil seuil" << endl; + cerr << "--stepssave\tsave steps of the algorithm" << endl; + throw 2; + } + if (verbose) + cout << "loading " << ficech << "..." << endl; + if (!OK (S.load (ficech.c_str ()))) + { + cerr << "impossible d'ouvrir " << ficech << endl; + throw 5; + } + + epsprime = precision*pow(double(S.size()),-0.25)/5; + epsprime = min(sqrt(precision),0.1); + + A.DEES (positive, S, precision, epsprime, verbose, moderet, modeeps, max_states, seuil,10,0,true,stepssave); + if (verbose) + cout << "saving A in " << ficffaA << endl; + A.save (ficffaA); + // affichage de l'automate + if (affiche_A) + { + show(A); + } + } + else if (arg == "--deesbm") { + // --- DEES version Baum Welch --- + if (argc > i) + { + ficech = argv[i]; + } + else + { + cerr << "--deesbm command learn an automaton using deesbm." << endl; + cerr << "usage: dees --deesbm [OPTIONS] sample" << endl; + cerr << "usefull options:" << endl; + cerr << "-p or --precision number" << endl; + cerr << "-v or --verbose" << endl; + cerr << "--max_states number\tmaximal number of states" << endl; + cerr << "--seuil number\tminimal number of suffix do use residual" << endl; + cerr << "--nb_tours number\tmax number of turns for Baum Welch" << endl; + cerr << "--seuilbm double\tprecision under which Baum Welch is considered to found the Max Likelihood Model" << endl; + cerr << "-o or --ficffaA file\ttarget file" << endl; + throw 2; + } + if (verbose) + cout << "loading " << ficech << "..." << endl; + if (!OK (S.load (ficech.c_str ()))) + { + cerr << "impossible d'ouvrir " << ficech << + endl; + throw 5; + } + + epsprime = precision*pow(double(S.size()),-0.25)/5; + + A.DEESBM (S, precision, epsprime, verbose, max_states, seuil, seuilbm, nb_tours); + if (verbose) + cout << "saving A in " << ficffaA << endl; + // A.emmonde(); + A.save (ficffaA); + // affichage de l'automate + if (affiche_A) + { + show(A); + } + } + else if (arg == "--deesha") + { + + if (argc > i) + { + ficech = argv[i]; + } + else + { + throw 1; + } + if (verbose) + cout << "loading " << ficech << "..." << endl; + if (!OK (S.load (ficech.c_str ()))) + { + cerr << "impossible d'ouvrir " << ficech << + endl; + throw 5; + } + + // epsprime = precision/(2*sqrt(sqrt(n))) + // epsprime est donc un o(precision) + epsprime = precision*pow(double(S.size()),-0.25)/5; + + A.DEES (nonconstrained, S, precision, epsprime, verbose, moderet,modeeps, max_states, seuil, maxmots); + if (verbose) + cout << "saving A in " << ficffaA << endl; + // A.emmonde(); + A.save (ficffaA); + // affichage de l'automate + if (affiche_A) + { + show(A); + } + } + else if ((arg == "--generate_complete_random_pfa") || (arg == "--gcrp")) + { // --- generation d'un pfa aléatoire complet --- + generate_complete_random_pfa(argc, argv, i); + } + else if ((arg == "--generate_random_pfa") || (arg == "--grp")) + { + generate_random_pfa(argc, argv, i); + } + else if (arg == "--proba") { // show values of words for an MA + show_sample_proba(argc, argv, i); + } + else if (arg == "--forward") { // show prefix values of words for an MA + show_sample_forward(argc, argv, i); + } + else if (arg == "--class") + { // --- show the class of the automaton + if (argc < 3) + throw 2; + A.load (argv[2]); + affiche_classe (A); + } + else if (arg == "--bm") { // Baum Welch Algorithm + if (argc < i+4) { + cerr << "dees --bm pfa sample number_of_turns output_pfa\n"; + cerr << "work baum welch using the pfa for initialisation (structure + parameters)\n"; + cerr << "remember Baum Welch never change a 0 valued parameter\n"; + return -1; + } + string pfa=argv[i++]; + string sample=argv[i++]; + int nb_turns=atoi(argv[i++]); + string output=argv[i++]; + + A.load(pfa); + S.load(sample); + BaumWelch(A,S,nb_turns,output); + } + else if (arg == "--convert") { + if (argc < i+3) { + cerr << "dees --convert format sample output\n"; + cerr << "Change the format of the sample to output.\n"; + cerr << "format could be dees for internal, alergia or mdi\n"; + return -1; + } + string format=argv[++i]; + string input=argv[++i]; + string output=argv[++i]; + S.load(input); + if (format == "alergia") { + S.save(output, alergia); + } + else if (format == "mdi") { + S.save(output, mdi); + } + else { + S.save(output); + } + } + else + { // ---------- choix non traitÈ ------------- + throw 1; + } + return EXIT_SUCCESS; + } + catch (int err) + { + switch (err) + { + case 1: + affiche_utilisation (); + cout << "Report bugs or suggestions to Yann Esposito ." << endl; + break; + case 2: + cerr << "\nNo enougth arguments" << endl; + break; + case 3: + cerr << "Input error, I cannot read the file." << + argv[i] << endl; + break; + case 4: + cerr << format << "is an unknown format." << endl; + break; + case 5: + cerr << "I/O Error !!!" << endl; + break; + default: + cerr << "unknown error occured !" << endl; + } + + if (err != 1) + { + cerr << "use -h, --help or -H option to display help" << endl; + } + } + catch (string erreur) { + cerr << erreur << endl; + } + catch (...) + { + cerr << "Unknown error !!!" << endl; + affiche_utilisation (); + return -1; + } +} \ No newline at end of file diff --git a/oldsimplex.H b/oldsimplex.H new file mode 100644 index 0000000..b00385f --- /dev/null +++ b/oldsimplex.H @@ -0,0 +1,31 @@ +#include "general.H" +#include // pour fabs + +// ------- La classe ---------- +class Simplex +{ +public: + //hash_map > a; // La matrice des contraintes + //hash_map sol; // Le tableau des solutions + //hash_map db; // Un tableau + //hash_map hb; // un autre tableau + + map > a; // La matrice des contraintes + map sol; // Le tableau des solutions + map db; // Un tableau + map hb; // un autre tableau + map::iterator it; // un itérateur sur les colonnes de a. + +public: + Simplex() {} + ~Simplex(){} + +private: + int ads_sortant(int m,int n,int phase); + int ads_entrant(int n,int l); + void pivotage(int m,int n,int l,int k); + int affiche(int ineq1, int ineq2, int nbeq, int nbvar); +public: + int simplexe_dual(int ineq1, int ineq2, int eq, int n); + int solve(int ineq1, int ineq2, int eq, int n, bool debug=false); +}; diff --git a/pfa.H b/pfa.H new file mode 100644 index 0000000..b0519cc --- /dev/null +++ b/pfa.H @@ -0,0 +1,112 @@ +/*************************************************************************** + pfa.h - Probabilistic Finite Automaton + ------------------- + begin : 7 Dec 2002 + copyright : (C) 2002 by Yann Esposito + email : esposito@cmi.univ-mrs.fr +***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +/*________________________ DÈscription plus prÈcise ______________________*\ + Classe qui hÈrite de la classe spfa, la seule diffÈrence est que l'on + peut gÈnÈrer des mots avec une distribution de probabilitÈ. + \***************************************************************************/ + +#ifndef PFA_H +#define PFA_H + +#include "spfa.H" +#include "sample.H" +//#include "simplex.H" + + +// ------------------------ La Classe ---------------------------------- + +class PFA : public SPFA +{ +public: + RESULT rend_PFA(void); + + // cree un PFA aleatoire + RESULT becomeRandom(int num_etat, int num_lettre, // le nombre d'etats et le nombre de lettres + int num_graphe = 0, // le numero du graphe (donner deux fois le mÃme numero avec + // les memes paramËtres donne le mÃme graphe + float densite=0.3, // densitÈ du ffa (0 ffa vide, 1 ffa complet) + float prob_init=0.3, // probabilitÈ d'Ãtre initial + float prob_term=0.3, // probabilitÈ d'Ãtre terminal + float min_trans=0, + float max_trans=1); // valeur maximale des transitions + + RESULT becomeRandomPrefix(const int nb_etats, // le nombre d'Ètats + const int nb_lettres, // le nombre de lettres + const int num_graphe = 0, // le numero du graphe + const float densite=0.3, // densitÈ du ffa (0 ffa vide, 1 ffa complet) + const float prob_init=0.3, // la probabilitÈ pour un Ètat d'etre initial + const float prob_term=0.3, // probabilitÈ pour un Ètat d'Ãtre terminal + const float min_trans = 0, // la valeur minimale des transitions + const float max_trans = 1); // la valeur maximale des transitions + // Cree un MA aleatoire avec un nombre maximal d'aretes + RESULT becomeRandomMax (const int nb_etats, const int nb_lettres, + const int num_graphe=0, const int nb_succ=2, + const int nb_init=1, const int nb_term=INT_MAX, + const float min_trans=0, const float max_trans=1); + + // genere un mot en corelation avec la distribution + RESULT genere_mot(Word &w, const bool safe = true); + // -- dans MA maintenant -- // genere un Èchantillon de mots + RESULT genere_echantillon(const int taille, Sample &S, const int num_echantillon=0); + // -- dans MA maintenant -- // genere un Èchantillon de mots + RESULT genere_echantillon(const int taille, Sample &S, const char *Filename, const int num_echantillon=0); + + // transforme un MA avec valeurs positives en SPFA + RESULT rend_spfa(void); + + // Lissage + RESULT lisse(int mode=0, float delta=0.01); + + // become the PTA representing S + RESULT becomePrefixTree(Sample &S); + + // ----------- DISTANCES ENTRE PFAs ----------- + + // renvoie la perplexitÈ du PFA par rappor ‡ l'echantillon S + double perplexite(const Sample &S) const; + // renvoie la divergence de Kullback Leibler relativemant ‡ l'Èchantillon S + double divKL(const PFA &B, const Sample &S); + // renvoie la divergence de Kullback Leibler relativemant ‡ l'Èchantillon S en utilisant B + double divKL (PFA &B, const Sample & S) const; + // renvoie la norme 2 entre ce PFA et le PTA correspondant ‡ S + double d_2(const Sample &S) const; + // renvoie la norme 2 entre ce PFA et un autre + double d_2(const PFA &B, const Sample &S) const; + // revoie la norme L1 entre ce PFA et un autre en fonction de l'Èchantillon + double L_1(const PFA &B, const Sample &S) const; + // renvoie la norme 2 entre ce PFA et un autre calculée sans passer par les logs + double d_2nlog(const PFA &B, const Sample &S) const; + // revoie la norme L1 entre ce PFA et un autre en fonction de l'Èchantillon calculé sans passer par les logs + double L_1nlog(const PFA &B, const Sample &S) const; + // renvoie la moyenne des Ècarts de log en fonction d'un Èchantillon S + double dlog(const PFA &B, const Sample &S) const; + // renvoie dlog sans prendre en compte les mots non gÈnÈrables par l'un des deux PFAs + double dlog_safe(const PFA &B, const Sample &S) const; + // renvoie la vraissemblance + float Likelihood(const Sample &S); + + + // return true if the MA is a PRFA + bool isPRFA(bool verbose=false); + + // return true if the PFA is a PDFA + bool isPDFA(); + +}; + +#endif diff --git a/pfa.cpp b/pfa.cpp new file mode 100644 index 0000000..23f081f --- /dev/null +++ b/pfa.cpp @@ -0,0 +1,713 @@ +/*************************************************************************** + pfa.cpp + ------------------- + begin : Mon 9 Dec 2002 + copyright : (C) 2002 by Yann Esposito + email : esposito@cmi.univ-mrs.fr +***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +/* + Pour les notes, voir le fichier "pfa.h". + See "pfa.h" file to view notes. +*/ +#include "pfa.H" +//#include +#include + +// renvoi vrai si le MA est un PFA +RESULT +PFA::rend_PFA (void) +{ + // on emmonde + MA::emmonde(); + // renormalisation of all parameters + renormalise(); + return VAL (0); +} + +RESULT +PFA::becomeRandom (const int nb_etats, const int nb_lettres, + const int num_graphe, const float densite, + const float prob_init, const float prob_term, + const float min_trans, const float max_trans) +{ + // on cree un SPFA + SPFA::becomeRandom (nb_etats, nb_lettres, + num_graphe, densite, + prob_init, prob_term, + min_trans, max_trans); + // puis on l'emmonde et on le renormalise. + return rend_PFA (); +} + +// Cree un MA aleatoire avec un nombre maximal d'aretes +RESULT PFA::becomeRandomMax (const int nb_etats, const int nb_lettres, + const int num_graphe, const int nb_succ, + const int nb_init, const int nb_term, + const float min_trans, const float max_trans) +{ + SPFA::becomeRandomMax(nb_etats, nb_lettres, num_graphe, nb_succ, nb_init, nb_term,min_trans,max_trans); + return rend_PFA(); +} + + +RESULT +PFA::becomeRandomPrefix (const int nb_etats, const int nb_lettres, + const int num_graphe, const float densite, const float prob_init, + const float prob_term, const float min_trans, + const float max_trans) +{ + + // On gÈnËre un MA alÈatoire avec seulement des arÃtes positives + SPFA::becomeRandomPrefix (nb_etats, nb_lettres, + num_graphe, densite, + prob_init, prob_term, + min_trans, max_trans); + + // on rend un SPFA + return rend_PFA (); +} + +// Arbre prefixe +RESULT PFA::becomePrefixTree(Sample &S) +{ + bool ispref = S.isprefixiel(); + if (!ispref) + { + S.prefixialise(); + } + + vide(); // on vide la structure du PFA + Sample::const_iterator w; + Lettre a; + Word v; + + Sigma=S.alphabet(); + alph=S.dictionnaire(); + + map< Word, State > R; + w = S.begin(); + R[w->first]=addNewState(1,0); + + // on commence apres epsilon d'ou le ++w au debut du for + for (++w ; w != S.end() ; ++w) + { + v=w->first; + R[v]=addNewState(0,0); + a=*(v.rbegin()); + v.erase(--v.end()); + addTransition(R[v], a , R[w->first],(float)S[w->first]/(float)S[v]); + } + // on met ‡ jour iota et tau + StateSet::const_iterator e; + Graph::const_iterator q; + LettreSFunc::const_iterator x; + SFunc::const_iterator r; + float sum; + for (e=Q.begin() ; e != Q.end() ; ++e) + { + sum = 0; + q=phi.find(*e); + if (q != phi.end()) + { + for (x=q->second.begin() ; x != q->second.end() ; ++x) + { + for (r=x->second.begin() ; r != x->second.end() ; ++r) + { + sum += r->second; + } + } + } + tau[*e]=1-sum; + } + + if (!ispref) + { + S.deprefixialise(); + } + return VAL(0); +} + + + +// Lissage +RESULT PFA::lisse (int mode, float delta) +{ + if (mode == 0) + { // Mode sale !!! + SFunc::iterator q; + Alphabet::const_iterator a; + float val; + State s; // le nouvel etat + + if (iota.empty ()) + { + s = addNewState(1,delta); + } + else + { + q = iota.begin (); + val = q->second * delta; + q->second = q->second * (1 - delta); + s = addNewState (val, delta); + } + val = 1 - delta; + for (a = Sigma.begin (); a != Sigma.end (); ++a) + addTransition (s, *a, s, val / (Sigma.size ())); + + return VAL(0); + } + else if (mode == 1) + { + cerr << "PFA::lisse(), mode " << mode << " non pris en compte" + << endl; + return ERR (1); + } + else + { + cerr << "PFA::lisse(), mode" << mode << " non pris en compte" << endl; + return ERR (0); + } +} + + + + + +// Vraissemblance +float PFA::Likelihood(const Sample &S) +{ + if (S.isprefixiel()) { + cerr << "PFA::Likelihood(const Sample &S) : S is prefixial !" << endl; + return -1; + } + + Sample::const_iterator w; + float result=0; +// cout.precision(19); + for (w=S.begin() ; w != S.end() ; ++w) + { + if (isnan(plog(w->first))) { + cerr << "ERREUR mot : " << w->first << endl; + } + else { + result += plog(w->first) * w->second; + } + } + + return result; +} + + +// genere un mot ‡ l'aide du PFA. +RESULT +PFA::genere_mot (Word & w, const bool safe) +{ + if (PFA_SAFE) + { + if (safe) + assert (isPFA ()); + } + + State jeton; + float alea; + float sum; + SFunc::const_iterator q; + LettreSFunc::const_iterator a; + + // w = mot vide + w.clear (); + + // choix de l'Ètat initial q + // on prend un nombre de [0,1[ + alea = ((float) rand ()) / INT_MAX; + // on prend le premier etat qui fait dÈpasser le seuil + q = iota.begin (); + sum = q->second; + while (sum < alea) + { + sum += (++q)->second; + } + jeton = q->first; // on a fait notre choix + + // Fin du choix : on commence dans l'Ètat jeton + // on genere le mot + // alea prend une valeur au hasard de [0,1[, puis tant que l'on ne s'arrete pas + // i.e. tant que alea > tau(jeton), + alea = ((float) rand ()) / INT_MAX; + while (alea > + (sum = + (tau.find (jeton) != + tau.end ())? (tau.find (jeton)->second) : 0)) + { + // on choisi une transition ‡ emprunter + a = (phi.find (jeton)->second).begin (); //On n'a pas besoin de faire un test sur le find ! + while (sum < alea) + { + q = a->second.begin (); + while ((q != a->second.end ()) && (sum < alea)) + { + if ((sum += q->second) < alea) + q++; + } + if (sum < alea) + a++; + } + // et on l'emprunte + jeton = q->first; + // on rajoute la lettre gÈnÈrÈe ‡ w + w += a->first; + //w.push_back (a->first); + + // on est dans l'Ètat "jeton" et on a ajoute la lettre "a->first" + //puis on recommence + alea = ((float) rand ()) / INT_MAX; + } + return VAL (0); +} + + + // genere un Èchantillon de mots + RESULT + PFA::genere_echantillon (int taille, Sample & S, + const int num_echantillon) + { + if (isPFA()) { + int i; + Word w; + if (num_echantillon != 0) + { + srand (num_echantillon); + } + + S = Sample (Sigma, alph, false); + for (i = 0; i < taille; i++) + { + genere_mot (w, false); + S.insert (w); + } + return VAL (0); + } + else { + return MA::genere_echantillon(taille, S, num_echantillon); + } + } + + // genere un Èchantillon de mots : l'echantillon reste identique si lot est identique + RESULT PFA::genere_echantillon (const int taille, + Sample & S, + const char *Filename, + const int num_echantillon) + { + if (PFA_DEBUG) + { + if (Filename == NULL) + { + cerr << " PFA::echantillon(int taille, char *Filename) : Filename = NULL !!!" << endl; + } + } + genere_echantillon (taille, S, num_echantillon); + return S.save (Filename); + } + +// ---------- DISTANCES --------- + +// renvoie la perplexité du PFA par rapport à l'echantillon S +double +PFA::perplexite (const Sample & S) const +{ + double res, sum; + Sample::const_iterator w; + + if (isPFA()) { + res = sum = 0; + for (w = S.begin (); w != S.end (); S.next (w)) + { + res += plog (w->first) * w->second; + sum += w->second; + } + } + else { + res = sum = 0; + for (w = S.begin (); w != S.end (); S.next (w)) + { + res += log (r(w->first)) * w->second; + sum += w->second; + } + } + return -res / sum; +} + +// renvoie la perplexitÈ du PFA par rappor ‡ l'echantillon S +double +PFA::divKL (PFA &B, const Sample & S) const +{ + double res, res2, sum; + Sample::const_iterator w; + + res = res2 = sum = 0; + for (w = S.begin (); w != S.end (); S.next (w)) + { + res += plog (w->first) * w->second; + res2 += B.plog(w->first) * w->second; + sum += w->second; + } + return (res2 - res) / sum; +} + + +// renvoie la norme 2 entre ce PFA et le PTA correspondant ‡ S +double +PFA::d_2(const Sample &S) const { + Sample::const_iterator w; + double res, sum; + double pA, pB; + double taille=double(S.size()); + + res = sum = 0; + for (w = S.begin (); w != S.end (); w++) + { + if (w->second >= S.seuil) + { + pA = p (w->first); + pB = double(w->second)/taille; + res += (pA - pB) * (pA - pB) * pA; + sum += pA; + } + } + + return sqrt (res / sum); +} + +// renvoie la norme 2 entre ce PFA et un autre +double +PFA::d_2 (const PFA & B, const Sample & S) const +{ + Sample::const_iterator w; + double res, sum; + double pA, pB; + + res = sum = 0; + + for (w = S.begin (); w != S.end (); w++) + { + if (w->second >= S.seuil) + { + pA = p (w->first); + pB = B.p (w->first); + res += (pA - pB) * (pA - pB) * pA; + sum += pA; + } + } + + return sqrt (res / sum); +} + +// renvoie la norme L1 entre ce PFA et un autre +double +PFA::L_1 (const PFA & B, const Sample & S) const +{ + Sample::const_iterator w; + double res, sum; + double pA, pB; + + res = sum = 0; + for (w = S.begin (); w != S.end (); w++) + { + if (w->second >= S.seuil) + { + pA = p (w->first); + pB = B.p (w->first); + res += (pA - pB >= 0) ? (pA - pB) * pA : (pB - pA) * pA; // |pA(w) - pB(w)|*pA(w) + sum += pA; + } + } + + return sqrt (res / sum); +} + + +// renvoie la norme 2 entre ce PFA et un autre +double +PFA::d_2nlog (const PFA & B, const Sample & S) const +{ + Sample::const_iterator w; + double res, sum; + double pA, pB; + + res = sum = 0; + + for (w = S.begin (); w != S.end (); w++) + { + if (w->second >= S.seuil) + { + pA = p_directe (w->first); + pB = B.p_directe (w->first); + res += (pA - pB) * (pA - pB) * pA; + sum += pA; + } + } + + return sqrt (res / sum); +} + +// renvoie la norme L1 entre ce PFA et un autre +double +PFA::L_1nlog (const PFA & B, const Sample & S) const +{ + Sample::const_iterator w; + double res, sum; + double pA, pB; + + res = sum = 0; + for (w = S.begin (); w != S.end (); w++) + { + if (w->second >= S.seuil) + { + pA = p_directe (w->first); + pB = B.p_directe (w->first); + res += (pA - pB >= 0) ? (pA - pB) * pA : (pB - pA) * pA; // |pA(w) - pB(w)|*pA(w) + sum += pA; + } + } + + return sqrt (res / sum); +} + + + +// renvoie la moyenne des Ècarts de log en fonction d'un Èchantillon S +double +PFA::dlog (const PFA & B, const Sample & S) const +{ + Sample::const_iterator w; + double res, sum, pa; + res = sum = 0; + for (w = S.begin (); w != S.end (); w++) + { + sum += w->second; + pa = plog (w->first) - B.plog (w->first); + if (pa < 0) + pa = -pa; + res += pa * w->second; + } + return res / sum; +} + +// renvoie la moyenne des Ècarts de log en fonction d'un Èchantillon S +double +PFA::dlog_safe (const PFA & B, const Sample & S) const +{ + Sample::const_iterator w; + double res, pa; + int sum, nb_err, nb_mots; + + res = sum = nb_err = nb_mots = 0; + for (w = S.begin (); w != S.end (); w++) + { + if (w->second >= S.seuil) + { + nb_mots++; + pa = plog (w->first) - B.plog (w->first); + if (!isnan (pa)) + { + sum += w->second; + if (pa < 0) + pa = -pa; + res += pa * w->second; + } + else + { + if (PFA_VERBOSE) + { + cerr << "\tErreur : "; + Word::const_iterator va; + for (va = w->first.begin (); + va != w->first.end (); va++) + cerr << alph.find (*va)-> + second << " "; + cerr << endl; + cerr << "\tpA = " << plog (w-> + first) << + " et pB = " << B.plog (w-> + first) + << endl; + } + nb_err++; + } + } + } + if (PFA_VERBOSE) + { + if (nb_err > 0) + cerr << nb_err * 100 / + nb_mots << "% d'erreur de structure." << endl; + } + return res / sum; +} + +// renvoie la divergence de Kullback Leibler relativemant ‡ l'Èchantillon S +double +PFA::divKL (const PFA & B, const Sample & S) +{ + return B.perplexite (S) - perplexite (S); +} + +// return true if it is a PRFA +bool +PFA::isPRFA (bool verbose) +{ + if (!isPFA()) + { + return false; + } + + // !!!!!!!!!!! VERSION NON DEFINITIVE !!!!!!!!!!!!!! + // !!!!! reduce is not yet implemented !!!!!!!!! + + //reduce(); + + map < State, bool > resStates; // resStates[q]=true iff q is reach uniquely by some word. + set + < StateSet> Memory; // the set of states even founded. + StateSet QI; // l'ensemble des Ètats initiaux + StateSet R; // Un ensemble d'Ètats + StateSet Qm; // l'ensemble des Ètats dont on a dÈja trouvÈ un mot caractÈristique. + set + < StateSet >::const_iterator Ri; + set + < Word > W; // un ensemble de mots + Word w; + Word::iterator b; + StateSet::const_iterator q; + SFunc::iterator r; + Alphabet::const_iterator a; + + //~ // -- // + //~ cout << "L'ensemble d'Ètats est : {"; + //~ StateSet::const_iterator s; + //~ for (s=Q.begin() ; s != Q.end() ; ++s) + //~ cout << *s << ","; + //~ cout << "}" << endl; + //~ // -- // + + // QI devient l'ensemble des Ètats initiaux + for (r=iota.begin();r != iota.end() ; ++r) + { + QI.insert(r->first); + } + + //~ // -- // + //~ cout << "QI={"; + //~ for (s=Q.begin() ; s != Q.end() ; ++s) + //~ cout << *s << ","; + //~ cout << "}" << endl; + //~ // -- // + + + // W = Sigma + for (a=Sigma.begin() ; a != Sigma.end() ; ++a) + { + w.clear(); + w += *a; + //w.push_back(*a); + W.insert(w); + } + + // Si il n'y a qu'un seul Ètat initial, alors + // son mot caractÈristique est epsilon + if (QI.size()==1) + { + Qm=QI; + if (verbose) + { + cout << "mot caractÈristique de " << *(Qm.begin()) << "\n"; + cout << "epsilon\n"; + cout << "longueur 0" << endl; + } + } + + // QI est la premiËre partie possible + Memory.insert(QI); + + while(!W.empty() && !(Qm==Q)) + { + w=*(W.begin()); // w=min W + W.erase(W.begin()); // W <- W \ {w} + R=delta(QI,w); + + //~ // -- Affichage de delta (QI, w) -- // + //~ cout << "delta(QI," << affiche(w) << ")={"; + //~ for (s = R.begin() ; s != R.end() ; ++s) + //~ cout << *s << ","; + //~ cout << "}" << endl; + //~ // -- // + + // si R \notin Memory + if (Memory.find(R) == Memory.end()) + { + // on rajoute R ‡ Memory + Memory.insert(R); + // W = W \cup w\Sigma + for (a=Sigma.begin() ; a != Sigma.end() ; ++a) + { + w += *a; + //w.push_back(*a); + W.insert(w); + b=w.end(); + w.erase(--b); + } + + // Si R contient un seul Ètat + if (R.size() == 1) + { + // Si cet Ètat n'a pas dÈja eu un mot caractÈristique + if (Qm.find(*(R.begin())) == Qm.end()) + { + // Alors on a trouver un nouvel Ètat dont on connait le + // mot caractÈristique (w) + Qm.insert(*(R.begin())); + if (verbose) + { + cout << "le mot caracteristique de l'Ètat " << *(R.begin()) << " est :\n"; + cout << affiche(w) << "\n"; + cout << "longueur " << w.size() << endl; + } + } + } + } + } + return Qm==Q; +} + +bool PFA::isPDFA() +{ + if (!isPFA()) + { + return false; + } + erase_transitions(0,0); // erasing null transition + if (iota.size() != 1) + return false; + Graph::const_iterator q; + LettreSFunc::const_iterator a; + SFunc::const_iterator r; + for (q=phi.begin() ; q != phi.end() ; ++q) + { + for (a=q->second.begin() ; a!=q->second.end() ; ++a) + { + if (a->second.size() > 1) + return false; + } + } + return true; +} diff --git a/pprfa.H b/pprfa.H new file mode 100644 index 0000000..723f9f7 --- /dev/null +++ b/pprfa.H @@ -0,0 +1,179 @@ +/*************************************************************************** + pfa.h - Probabilistic Finite Automaton + ------------------- + begin : 7 Dec 2002 + copyright : (C) 2002 by Yann Esposito + email : esposito@cmi.univ-mrs.fr +***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +/*________________________ DÈscription plus precise ______________________*\ + Classe qui herite de la classe spfa, la seule diffÈrence est que l'on + peut generer des mots avec une distribution de probabilite. + \***************************************************************************/ + +#ifndef PPRFA_H +#define PPRFA_H + +#include "pfa.H" +#include "simplex.H" + + +typedef enum {determinist, positive, nonconstrained} T_ModeVariables; +typedef enum {begin, end} T_ModeReturn; +typedef enum {epsfixed, variable, word_variable} T_ModeEpsilon; + + +class PPRFA : public PFA +{ +protected: + WordSFunc XR; + +public: + // become the PTA representing S but successor of v are returned + RESULT becomeQuasiPrefixTree ( const Sample &S, const Word &v, const SFunc &solution); + // erase the transition w,l,v + RESULT eraseTransition(const Word &w, const Lettre l, const Word &v); + // emmonde + RESULT emmonde(void); + +protected: + // fonction necessaire ‡ sol + RESULT liste_mots_associes(WordSet &W, + const Word &v, + const Sample &S, + int maxmots = 10) const; + // fonction necessaire ‡ liste_mots_associes + RESULT ajoute_mots_associes(WordSet &W, + const Word &v, + const Sample &S, + int maxmots = INT_MAX) const; + // renvoie vide si le systËme lineaire I(v,R,S,precision) n'a pas de solution et + // sinon renvoie une solution de I i.e. un ensemble de variables X_q telles que + // v^{-1}P = \sum_{q \in R} X_qP_q -- en rappelant que R[w]=q => P_q = w^{-1}P + // on ne prend en compte que au plus max mots. + RESULT solmax(T_ModeVariables modeVariables, + SFunc &solution, // La solution + const Word &v, + const Sample &S, + Simplex &simplx, + const double precision, + const T_ModeReturn moderet, + const T_ModeEpsilon modeeps, + set + &W, + unsigned int max) const; + // renvoie vide si le systËme lineaire I(v,R,S,precision) n'a pas de solution et + // sinon renvoie une solution de I i.e. un ensemble de variables X_q telles que + // v^{-1}P = \sum_{q \in R} X_qP_q -- en rappelant que R[w]=q => P_q = w^{-1}P + RESULT sol(T_ModeVariables modeVariables, + SFunc &solution, // La solution + const Word &v, + const Sample &S, + Simplex &simplx, + const double precision, + const T_ModeReturn moderet, + const T_ModeEpsilon modeeps, + set + &W, + int maxmots=10, + bool Wcalculated = false) const; + + inline RESULT addTransition(const Word &wdep, const Lettre a, const Word &warr, const float val) + { + return PFA::addTransition(XR[wdep], a, XR[warr], val); + } + + inline RESULT addTransition(const Word &wdep, const Lettre a, const State qarr, const float val) + { + return PFA::addTransition(XR[wdep], a, qarr, val); + } + + inline void vide() + { + XR.clear(); + PFA::vide(); + } + + + inline RESULT addState(const Word &w, const float init=0, const float term=0) + { + WordSFunc::const_iterator q; + q=XR.find(w); + if (q != XR.end()) { + return MA::addState( q->second, init, term); + } + else + { + return XR[w]=addNewState(init, term); + } + } + + float best_transition_delete(Sample Stest, bool verbose = false); + + +public: + // become PTA + RESULT becomePrefixTree(Sample &S); + // Apprentissage de PRFA, renvoie un PRFA prefixe + // prec prend la precision, et mode est le mode d'apprentissage + RESULT DEES(T_ModeVariables modeVariables, // the learning space for variables + Sample &S, // The learning sample (data) + const double prec, // The precision parameter + const double epsprime, // The bound under which transition are erased + const bool verbose = false, // verbose mode (show the states during construction) + const T_ModeReturn moderet = end, // return mode (end of the tree or begin of the tree) + const T_ModeEpsilon modeeps = variable, // epsilon mode (epsfixed or variable) + unsigned int maxstates = INT_MAX, // The maximal states number after which learning is cancelled + unsigned int seuil=10, // La periodicitÈ minimum avant de ne plus considÈrer l'Ètat + int maxmots=10, // le nombre maximal de mots que l'on reconsidËre ‡ chaque Ètape + int maxsearches=0, // le nombre de recherche dichotomique pour trouver le meilleur epsilon + bool bestsearch=true, // vrai si on recherche le meilleur epsilon + bool stepssave=false); // vrai sauvegarde chaque etape de l'apprentissage + + // Apprentissage de PRFA, renvoie un PRFA prefixe + // prend la precision, et mode est le mode d'apprentissage + RESULT DEESBM(Sample &S, // The learning sample (data) + const double prec, // The precision parameter + const double epsprime, // The bound under which transition are erased + const bool verbose = false, // verbose mode (show the states during construction) + const unsigned int maxstates = INT_MAX, // The maximal states number after which learning is cancelled + const unsigned int seuil=10, // La periodicitÈ minimum avant de ne plus considÈrer l'Ètat + const double seuilbm=0.0001, // Le seuil en dessous duquel on considère avoir trouver le MLM + const unsigned int nb_tours=10); // Le nombre de tours pour BM + + Word word_of(const State x) const; + + +protected: + + // ##### Pour la version Baum Welch ##### + RESULT setRandomSolution(SFunc &solution, const StateSet &R) const ; + RESULT BMsol (SFunc &solution, const Word &v,const Sample &S, const Sample &Sdep, const float prec,int nb_tours, bool verbose = false); + // recupere la solution en fonction des valeurs recuperes apres Baum Welch + RESULT get_solution(const PPRFA &A,SFunc &solution, Transition &t,TransitionFunction &T,const StateSFunc &Trad); + // Ajoute les etats necessaires pour que tous les mots vS soient generables + RESULT put_prefix_tree(const Sample &S, const Word &v); + // Ajoute les etats necessaires pour que le mot w deviennent generable + RESULT add_word(const State q, const Word &w); + // Liste les successeurs d'elements de Q qui ne sont pas dans Q + RESULT choice(list &X, const StateSet Q) const; + RESULT difference(const TransitionFunction T1, const TransitionFunction T2) const; + // Initialise la solution en utilisant une resolution de systeme d'equation + RESULT initSolution(SFunc &solution, const State x, const StateSet &R, const Sample &S) const; + // Construit un quasi pta et teste sa qualite par rapport a l'echantillon + bool TestQPTA(const Sample &S,const State x, const StateSet R,const double precision, const double seuilbm, bool verbose); + // remet a jour la liste des mots associes aux etats + RESULT compute_XR(void); + + }; + +#endif diff --git a/pprfa.cpp b/pprfa.cpp new file mode 100644 index 0000000..7c186e5 --- /dev/null +++ b/pprfa.cpp @@ -0,0 +1,339 @@ +/*************************************************************************** + pprfa.C + ------------------- + begin : Mon 9 Dec 2002 + copyright : (C) 2002 by Yann Esposito + email : esposito@cmi.univ-mrs.fr + +***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +/* + Pour les notes, voir le fichier "pprfa.h". + See "pprfa.h" file to view notes. +*/ + +#include "pprfa.H" + +// Best Suppression +float PPRFA::best_transition_delete(Sample Stest, bool verbose) { + + if (phi.empty()) { + return ERR(0); + } + else if (phi.begin()->second.empty()) { + return ERR(1); + } + else if (phi.begin()->second.begin()->second.empty()) { + return ERR(2); + } + + // Recherche des transitions à supprimer + Graph::iterator q; + LettreSFunc::iterator a; + SFunc::iterator s; + float min; + PPRFA C=*this; + + float perplex; + float minperplex; + float epsprime; + + lisse(); + minperplex = perplexite(Stest); + if (verbose) { + cout << "\tepsprime = 0"; + cout << ", distance = " << minperplex << endl; + } + min=0; + perplex=minperplex; + do + { + epsprime = min; + minperplex = perplex; + + min = phi.begin()->second.begin()->second.begin()->second; + + for (q = phi.begin(); q != phi.end(); ++q) + { + for (a = q->second.begin (); a != q->second.end (); ++a) + { + for (s = a->second.begin (); s != a->second.end (); ++s) + { + if ((s->second < min) && (s->second > epsprime)) + { + min = s->second; + } + } + } + } + if (min == epsprime) { + break; + } + erase_transitions (min); + rend_PFA (); + lisse (); + perplex = perplexite (Stest); + *this = C; + if (verbose) { + cout << "\tepsprime = " << min; + cout << ", distance = " << perplex << endl; + } + } + while (perplex <= minperplex); + if (verbose) { + cout << "\t|| Meilleur epsprime trouve = " << epsprime; + cout << ", mindist = " << minperplex << " ||" << endl; + } + *this = C; + erase_transitions (epsprime); + rend_PFA(); + + return d_2(Stest); +} + + + +RESULT PPRFA::eraseTransition(const Word &w, const Lettre l, const Word &v) { + return PFA::eraseTransition(XR[w],l,XR[v]); +} + +// fonction qui associe ‡ un etat le mot correspondant +Word PPRFA::word_of(const State x) const { + WordSFunc::const_iterator r; + for (r=XR.begin() ; r != XR.end() ; r++) { + if (r->second == x) + return r->first; + } + // on sort de la boucle sans avoir trouve !!! + cerr << "WORD_OF !!! etat : " << x << endl; + return ""; +} + +RESULT PPRFA::compute_XR(void) { + StateSet W; + StateSet R; + State etat_cour; + Word u; + Graph::const_iterator q; + LettreSFunc::const_iterator a; + SFunc::const_iterator s; + StateWordFunction WS; + W.insert (iota.begin ()->first); + + XR.clear(); + XR[u]=iota.begin()->first; + WS[iota.begin()->first]=u; + while (!W.empty ()) + { + etat_cour = *W.begin (); + W.erase (W.begin ()); + q = phi.find (etat_cour); + if (q != phi.end ()) + { + for (a = q->second.begin (); a != q->second.end (); ++a) + { + for (s = a->second.begin (); s != a->second.end (); ++s) + { + if (R.find(s->first) == R.end()) { + u=WS[etat_cour] + string(1,a->first); + XR[u]=s->first; + WS[s->first]=u; + W.insert (s->first); + R.insert(s->first); + } + } + } + } + } + return VAL(0); +} + + + + +// addStates from q to generate w from P_q(w) +RESULT PPRFA::add_word( const State q, const Word &w) { + if (w.empty()) { + if ((tau.find(q) == tau.end()) || (tau.find(q)->second == 0)) { + tau[q] = 0.01; + return VAL(1); + } + else { + return ERR(1); + } + } + else if (delta(q, string(1,*w.begin())).empty()) { + WordSFunc::const_iterator xr; + for (xr = XR.begin() ; + (xr != XR.end()) && (xr->second != q) ; + xr++) + ; + + if (xr == XR.end()) { + return ERR(2); + } + + Word u=xr->first; + State r,s; + Word::const_iterator a; + r=q; + for (a = w.begin() ; a != w.end() ; a++) { + u+=*a; + s=addState(u,0,0); + PFA::addTransition(r, *a , s, 0.01); + r=s; + } + return VAL(0); + } + else { + return ERR(2); + } +} + +RESULT PPRFA::emmonde(void) { + PFA::emmonde(); + WordSFunc::iterator r,s; + for (r=XR.begin() ; r != XR.end() ; ) { + if (Q.find(r->second) == Q.end()) { + s=r; + s++; + XR.erase(r); + r=s; + } + else { + r++; + } + } + return VAL(0); +} + +// Add Prefix many Tree in order to recognize all the sample +RESULT PPRFA::put_prefix_tree(const Sample &S, const Word &v) { + Sample::const_iterator w; + StateSet Q1; + StateSet::const_iterator q; + Word::const_iterator a; + for (w=S.begin() ;w != S.end() ; w++) { + //~ // ---- + //~ cout << "Mot : " << w->first << endl; + //~ // ---- + + // we are in a PPRFA then there is exactly one initial state + Q1.clear(); + Q1.insert(iota.begin()->first); + for (a=w->first.begin() ; a != w->first.end() ; a++) { + + //~ // ---- + //~ cout << "Q1={"; + //~ for (StateSet::const_iterator s=Q1.begin() ; s != Q1.end() ; s++) { + //~ cout << *s << ","; + //~ } + //~ cout << "}" << endl; + //~ // ---- + + // si pour un q delta(q,a) est vide, on ajoute les etat + // a partir de q pour reconnaitre la fin du mot + for (q=Q1.begin() ;q != Q1.end() ;q++) { + if (delta(*q , string(1,*a)).empty()) { + //~ // ---- + //~ cout << "add_word(" << *q << ",'" << flush; + //~ cout << string(a,w->first.end()) << "','" << flush; + //~ cout << string(w->first.begin(), a) << "')"<< endl; + //~ // ---- + add_word(*q,string(a,w->first.end())); + } + } + Q1 = delta(Q1,string(1,*a)); + } + + //~ // ---- + //~ cout << "Q1={"; + //~ for (StateSet::const_iterator s=Q1.begin() ; s != Q1.end() ; s++) { + //~ cout << *s << ","; + //~ } + //~ cout << "}" << endl; + //~ // ---- + + for (q = Q1.begin() ; q != Q1.end() ; q++) { + if (tau.find(*q) == tau.end() || (tau.find(*q)->second == 0)) { + //~ // ---- + //~ cout << "add_word(" << *q << ",'" << flush; + //~ cout << "','" << flush; + //~ cout << w->first << "')"<< endl; + //~ // ---- + add_word(*q,""); + } + } + } + return VAL(0); +} + +// Arbre prefixe +RESULT PPRFA::becomePrefixTree(Sample &S) +{ + bool ispref = S.isprefixiel(); + if (!ispref) + { + S.prefixialise(); + } + + vide(); // on vide la structure du PFA + Sample::const_iterator w; + Lettre a; + Word v; + + Sigma=S.alphabet(); + alph=S.dictionnaire(); + + w = S.begin(); + XR[w->first]=addNewState(1,0); + + // on commence apres epsilon d'ou le ++w au debut du for + for (++w ; w != S.end() ; ++w) + { + v=w->first; + XR[v]=addNewState(0,0); + a=*(v.rbegin()); + v.erase(--v.end()); + PFA::addTransition(XR[v], a , XR[w->first],(float)S[w->first]/(float)S[v]); + } + // on met ‡ jour iota et tau + StateSet::const_iterator e; + Graph::const_iterator q; + LettreSFunc::const_iterator x; + SFunc::const_iterator r; + float sum; + for (e=Q.begin() ; e != Q.end() ; ++e) + { + sum = 0; + q=phi.find(*e); + if (q != phi.end()) + { + for (x=q->second.begin() ; x != q->second.end() ; ++x) + { + for (r=x->second.begin() ; r != x->second.end() ; ++r) + { + sum += r->second; + } + } + } + tau[*e]=1-sum; + } + + if (!ispref) + { + S.deprefixialise(); + } + return VAL(0); +} + + diff --git a/pprfa_bm.cpp b/pprfa_bm.cpp new file mode 100644 index 0000000..d65ca97 --- /dev/null +++ b/pprfa_bm.cpp @@ -0,0 +1,422 @@ +/* + * pprfa_bm.cpp + * dees + * + * Created by Yann Esposito on 18/04/06. + * Copyright 2006 __MyCompanyName__. All rights reserved. + * + */ + +#include "pprfa.H" + +RESULT PPRFA::becomeQuasiPrefixTree ( + const Sample &S, // les mots + const Word &v, // le mot de retour + const SFunc &solution) // les valeurs initiales pour le retour +{ + Word w=v; + Lettre a; + SFunc::const_iterator s; + Transition t; + float val; + + w=v; + a=*(w.rbegin()); + w.erase(--w.end()); + // on a v = wa + + // val = w^{-1}P(a\Se) + val=exp(plog_bar(v) - plog_bar(w)); + + + // on supprime la transition deterministe phi(w,a,v) + eraseTransition(w,a,v); + + // on fait les retours + t.qdep = XR[w]; + t.a = a; + for (s=solution.begin() ; s != solution.end() ; s++ ) { + t.qarr = s->first; + PFA::addTransition(t,s->second*val); + } + + // on emmonde + emmonde(); + + put_prefix_tree(S,v); + + return VAL(0); +} + + + +RESULT PPRFA::setRandomSolution(SFunc &solution, const StateSet &R) const +{ + StateSet::iterator q; + for (q = R.begin() ; q != R.end() ; ++q) + { + solution[*q] = random(0,1); + } + float sum=0; + SFunc::iterator s; + for (s=solution.begin() ; s != solution.end() ; ++s) + { + sum += s->second; + } + for (s=solution.begin() ; s!=solution.end() ; ++s) + { + s->second /= sum; + } + return VAL(0); +} + + +RESULT PPRFA::choice(list &X, const StateSet R) const { + StateSet::const_iterator q; + Graph::const_iterator r; + LettreSFunc::const_iterator a; + SFunc::const_iterator s; + + X.clear(); + for (q=R.begin() ; q!= R.end() ; q++) { + r=phi.find(*q); + if (r != phi.end()) { + for (a=r->second.begin() ; a != r->second.end() ; a++) { + for (s=a->second.begin() ; s != a->second.end() ; s++) { + if (R.find(s->first) == R.end()) { + if (Q.find(s->first) != Q.end()) + X.push_back(s->first); + else { + cerr << "Choice !!! automate non coherent, "; + cerr << "Etat : "<< s->first << endl; + cerr << "Sauvegarde dans test/uncoherent" << endl; + save("test/uncoherent"); + } + } + } + } + } + } + return VAL(0); +} + +RESULT PPRFA::difference(const TransitionFunction T1, + const TransitionFunction T2) const { + TransitionFunction::const_iterator t; + float res=0; + for (t=T1.begin() ; t != T1.end() ; t++) { + res+=abs(t->second - T2.find(t->first)->second); + } + res = res/float(T1.size()); + return VAL(0); + } + + + +// compte le nombre de fois que l'on passe par l'etat x en lisant S +float SPFA::count_nb_pass(const State x, const Sample &S) const { + TransitionFunction T; + SFunc Iota, Tau; + + // on met dans T toutes les transitions qui arrivent + // dans l'etat x + Graph::const_iterator q; + LettreSFunc::const_iterator a; + SFunc::const_iterator r; + Transition t; + t.qarr=x; + for (q=phi.begin() ;q != phi.end() ; q++) { + t.qdep = q->first; + for (a = q->second.begin() ; a != q->second.end(); a ++) { + t.a=a->first; + if (a->second.find(x) != a->second.end()) { + T[t]=0; + } + } + } + + TransitionCount(S,T,Iota,Tau); + TransitionFunction::const_iterator ti; + float res; + res = 0; + for (ti=T.begin() ; ti != T.end() ; ti++) { + res+=ti->second; + } + return res; +} + +// init the state solution +RESULT PPRFA::initSolution(SFunc &solution, const State x, const StateSet &R, const Sample &S) const { + + // a small security test + if (! S.isprefixiel()) { + cerr << "WARNING ! initSolution called with a not prefixialised Sample\n"; + return setRandomSolution(solution,R); + } + + Word v; + WordSet W; + StateWordFunction wordof; + StateSet::const_iterator r; + Simplex simplx; // simplx est juste l'objet Simplex qui permet de résoudre les problèmes + int i; + int it; // un iterateur + WordSet::const_iterator wr; + StateWordFunction::const_iterator q; + double s1; + double s2; + WordSet::const_iterator wi; + double pvw; // v^{-1}P(w) + double precision; + + // --- Initialisation --- + v=word_of(x); // v est le mot initial + for (r=R.begin() ; r != R.end() ; r++) { + wordof[*r]=word_of(*r); + } + // wordof contient les les mots associes aux etats + ajoute_mots_associes(W,v,S,INT_MAX); // W contient les successeurs de v dans S + + // -- Remplissage du Simplex --- + // number of variables = number of core states + //n = R.size(); + + simplx.set_number_of_unknown_to(R.size()); + simplx.setval(1); + simplx.setparam(1,0); + for (q = wordof.begin(),it=1; q != wordof.end(); q++) + simplx.setparam(it++, 1); + simplx.add_equality_constraint(); + + simplx.setparam(1,1); + // inequations en <= (nb=ineq1), inequations en >= (nb=ineq2) + // les inequations X_q >= 0 sont deja + // prisent en comptent de manière implicite + s2=S[v]; + precision= 2/sqrt(double(s2)); + for (wi = W.begin(), i=1; wi != W.end () ; wi++, i++) + { + s1 = S[(v + *wi)]; + pvw = (double) s1 / (double) s2; + simplx.setval(pvw); + + for (q = wordof.begin(),it=1; q != wordof.end(); q++, it++) + { + s1 = S[q->second + *wi]; + s2 = S[q->second]; + if (s2 == 0) { + // cerr << "WARNING: " << q->second << ", random initialisation" << endl; + return setRandomSolution(solution,R); + } + + simplx.setparam(it, s1/s2); + } + simplx.add_absolute_constraint(); + } + + map preciseSol; + float epsilon; + bool err = simplx.has_solution(preciseSol,epsilon); + if ((! err) || (epsilon>precision)) + { // pas de solutions + setRandomSolution(solution,R); + return ERR(0); + } + else + { + solution.clear (); + for (q = wordof.begin(),it=2; q != wordof.end() ; q++, it++) + { + solution[q->first] = preciseSol[it]; + // cout << q->first << " SSS=" << simplx.sol[it]<> toto; + // ---- + */ + + // on fait les BaumWelch + TransitionFunction T1,T2; + SFunc Iota,Tau; + + A.allTransitions(T1); + T2=T1; + A.allStates(Tau); + + A.BaumWelch(S,T1,Iota,Tau,1, verbose); + A.BaumWelch(S,T2,Iota,Tau,1, verbose); + nb_tours=20; + while ((difference(T1,T2)>seuilbm) && (nb_tours-- > 0)) { + T2=T1; + A.BaumWelch(S,T1,Iota,Tau,1, verbose); + if (verbose) { + cout << "." << flush; + } + } + if (verbose) { + cout << "\n"; + } + + if (verbose) { + cout << "validation de la solution (" << affiche(v) << "): "; + } + + // Test pour la validation de T + // ---- + // if (verbose) { + // float x1, x2, x3, x4; + // x1 = A.Likelihood(S); + // x2 = S.AutoLikelihood(); + // x3 = nprime; + // x4 = S.size(); + // cout << "Hyp L=" << x1 << ", "; + // cout << "PTA L="<< x2 << ", "; + // cout << "nb(v)=" << x3 << ", "; + // cout << "Ssize=" << x4 << ", "; + // cout << "seuil=" << (x2-x1)*(sqrt(double(nprime))/double(S.size())); + // cout << endl; + // } + // ---- + + float valtest=(abs( A.Likelihood(S) - S.AutoLikelihood() ) * sqrt(double(nprime))) / double(S.size()); + if (verbose) { + cout << valtest << " < " << precision << endl; + } + if ( valtest > precision) { + return false; + } + else { + *this=A; + return true; + } +} + +RESULT PPRFA::DEESBM(Sample &S, // The learning sample (data) + const double prec, // The precision parameter + const double epsprime, // The bound under which transition are erased + const bool verbose, // verbose mode (show the states during construction) + const unsigned int maxstates, // The maximal states number after which learning is cancelled + const unsigned int seuil, // La periodicitÈ minimum avant de ne plus considÈrer l'Ètat + const double seuilbm, // la dist à partir de laquelle on considere avoir trouver le MLM + const unsigned int nb_tours ) // Le nombre de tour de BM +{ + + try { + list X; // the set of considered words + State x; + StateSet R; // the set of traited states + becomePrefixTree(S); // it's clear + R.insert(iota.begin()->first); + choice(X,R); // we add all states corresponding to letters + while (!X.empty()) { + x=*(X.begin()); X.pop_front(); + if ((Q.find(x) != Q.end()) && ( !TestQPTA(S,x,R, prec, seuilbm, verbose)) ) { // si on ne fait pas de retour + R.insert(x); + choice(X,R); + } + } + erase_transitions(0.01,0); + rend_PFA(); + return VAL(0); + } + catch (string e) { + cerr << "DEESBM() "; + cerr << e << endl; + return ERR(0); + } +} + + +RESULT PPRFA::get_solution(const PPRFA &A, + SFunc &solution, + Transition &t, + TransitionFunction &T, + const StateSFunc &Trad) +{ + LettreSFunc::const_iterator a; + SFunc::const_iterator r; + SFunc::iterator s; + float sum; + a=A.phi.find(t.qdep)->second.find(t.a); + + for (r = a->second.begin() ; r != a->second.end() ; ++r) { + t.qarr=r->first; + solution[Trad.find(r->first)->second]=T[t]; + } + + sum = 0; + for (s=solution.begin() ; s != solution.end() ; ++s) { + sum += s->second; + } + if (sum == 0) { + throw 1; + } + + for (s = solution.begin() ; s != solution.end() ; ++s) { + s->second /= sum; + } + + return VAL(0); + + // ---- + for (s=solution.begin() ; s != solution.end() ; ++s) { + cout << "sol[" << s->first << "] = " << s->second << " "; + } + cout << endl; + // ---- + +} + diff --git a/pprfa_dees.cpp b/pprfa_dees.cpp new file mode 100644 index 0000000..871b0ce --- /dev/null +++ b/pprfa_dees.cpp @@ -0,0 +1,536 @@ +/* + * pprfa_dees.cpp + * dees + * + * Created by Yann Esposito on 18/04/06. + * Copyright 2006 __MyCompanyName__. All rights reserved. + * + */ + +#include "pprfa.H" + +// ================================================================ +// === === +// === DEES === +// === === +// ================================================================ + +// Methode d'apprentissage d'un PRFA prefixe +RESULT +PPRFA::DEES (T_ModeVariables modeVariables, + Sample & S, + double prec, + double epsprime, + bool verbose, + T_ModeReturn moderet, + T_ModeEpsilon modeeps, + unsigned int maxstates, + unsigned int seuil, + int maxmots, + int maxsearches, + bool bestsearch, + bool stepssave) +{ + try { + // ------------------------- affichage des informations ---------------------- // + if (verbose) + { + cout << "\t\t=== DEES ==="; + cout << "\nSample size = " << S.size (); + cout << "\nprecision = " << prec; + cout << "\nbound = " << epsprime; + cout << "\nmoderet = "; + switch (moderet) + { + case begin: + cout << "begin"; + break; + case end: + cout << "end"; + } + cout << "\nmodeeps = "; + switch (modeeps) + { + case epsfixed: + cout << "epsfixed"; + break; + case variable: + cout << "variable"; + break; + case word_variable: + cout << "word_variable"; + break; + } + cout << "\nmaxstates = " << maxstates; + cout << "\nseuil = " << seuil; + cout << "\nmaxmots = " << maxmots << endl; + } + + if (prec == 0) { + return becomePrefixTree(S); + } + + // -------------------------- INITIALISATION ---------------------- + vide (); // on initialise le PFA. + if (S.size () == 0) + throw 0; // on verifie que l'echantillon n'est pas vide. + S.prefixialise (); // Transformation de l'Èchantillon en echantillon prefixiel. + Sigma = S.alphabet (); // on met ‡† jour l'alphabet + alph = S.dictionnaire (); // et le dictionnaire associÈ. + + // Declaration + Word v; // the word v which represent the word associated to the state to add. + list < Word > X; // The set of words which are potential prime residuals. + Sample::const_iterator u; // current word of the sample. + float val; // a floating value used to calculate tau. + Word w; // a word + Word ww; // another word + Lettre a; // a letter (we will have v=wa) + Alphabet::const_iterator b; // pour enumerer toutes les lettres + SFunc solution; // the system solution + SFunc solutiontemp; // a temporary solution + StateSet::iterator q; // Pour enumerer les états + Simplex simplx; // L'objet simplexe qui contient les algorithmes de resolution de systemes. + set < Word, ordre_mot > W; // L'ensemble de mots à tester + Word::iterator z; // last letter + + // --- init variables --- + v.clear (); // v = epsilon (empty word) + // X is the set of one letter words of S when prefixialised + val = 0; + for (u = ++(S.begin ()); + (u != S.end ()) && (u->first.size () < 2); ++u) + { + X.push_back (u->first); + val += u->second; + } + // We create the first state (epsilon) + addState (v, 1, 1 - (float(val) / float(S.size ()))); + W.clear (); + + // liste_mots_associes(W,v,S,maxmots); + ajoute_mots_associes(W,v,S,maxmots); + + // There may be a general state + State generalstate = -1; + + // Step saving + string svgfile="etape-"; + + // -------------------------- LEARNING LOOP ----------------------- + if (verbose) + cout << "Ajout des états : " << endl; + + // For each element in X (the temporary list) + while (!X.empty ()) + { + v = *(X.begin ()); // v <-- min X; + X.pop_front (); // X <-- X\{v} ; + // wa=v + w = v; + a = *(w.rbegin ()); + z = w.end (); + --z; + w.erase (z); //w.pop_back (); + + //~ if (verbose) { + //~ cout << "["; + //~ cout << affiche(v) <<"]"; + //~ cout.flush(); + //~ } + + if (stepssave) { + save(svgfile+affiche(v)); + } + + + /// 3 possible cases : + /// (1) not enought data (make a loop to the general state) + /// (2) there is no solution (add a new state and update X) + /// (3) there is a solution (make a return of transitions) + + if (S[v] < seuil) // case (1) not enought data + { + // cout << "CASE (1)" << endl; + if (generalstate == -1) + { // if the general state was not created, we create it + generalstate = addState (v, 0, 1 / float(Sigma.size () + 1)); + for (b = Sigma.begin (); b != Sigma.end (); ++b) + { + MA::addTransition (generalstate, *b, generalstate, 1 / float(Sigma.size () + 1)); + } + } + + addTransition (w, a, generalstate, ((double) S[v] / (double) S[w])); + XR[w + a] = generalstate; + if (verbose) + { + cout << "S"; + cout.flush (); + } + } + else + { + solution.clear (); // init solutions + // calculate the solution of the linear system + sol (modeVariables, solution, v, S, simplx, prec / pow(float(S[v]), float(0.4)), moderet, modeeps, W, maxmots, false); + if (solution.empty ()) // if there is no solution (case (2) add a new state and update X + { + // cout << "CASE (2)" << endl; + + // if there is no solution then we add the state associated with v + // updating X and tau (val will contain tau[v]) + val = 0; + for (b = Sigma.begin (); b != Sigma.end (); b++) + { // pour toute les lettres de l'alphabet + v += *b; + //v.push_back (*b); // on ajoute b a la fin de v + if (S.find (v) != S.end ()) + { // si vb appartient a l'echantillon, alors + X.push_back (v); // on l'ajoute a X + val += S[v]; // et val = val + S(vb\Sigma^*) + } + z = v.end (); + --z; + v.erase (z); //v.pop_back (); // on efface la derniere lettre pour que la variable v = le mot v. + } + + if (verbose) + { + cout << "A"; + cout.flush (); + } + + addState (v,0, 1 - (val / (double) S[v])); // adding the new state + if (size () > maxstates) + throw 1; + addTransition (w, a, v, ((double) S[v] / (double) S[w])); // updating phi : phi(w,a,wa) = S(wa)/S(w) + + } + else + { + // cout << "CASE (3)" << endl; + + // else we return transitions + + if (verbose) + { + cout << "R"; + cout.flush (); + } + + for (q = Q.begin (); q != Q.end (); q++) + { + val = (float) solution[*q] * + ((double) S[v] / (double) S[w]); + if (val != 0) + { + addTransition (w, a, *q, val); + } + } + } + } + } + if (verbose) + cout << endl; + + erase_transitions (epsprime, -epsprime); // deleting transitions less than epsprime + //best_transition_delete(S,verbose); + if (modeVariables == nonconstrained) { + return VAL(0); + } + else { + return renormalise (); // renormalisation in order to disable borders effects + } +} +catch (int erreur) { + if (PFA_VERBOSE) + { + if (erreur != 1) + { + cerr << "PFA::DEES(Sample S)" << endl; + } + switch (erreur) + { + case 0: + cerr << "Sample vide !!!" << endl; + break; + case 1: // il y a trop d'etats + erase_transitions (epsprime); + return renormalise (); + break; + default: + cerr << "Erreur n∞" << erreur << endl; + } + } + return ERR (erreur); +} +} + + + +RESULT PPRFA::ajoute_mots_associes (set &W, + const Word & v, + const Sample & S, + int maxmots) const +{ + list < Word > L; // une liste de mot qui sert pour calculer W + Alphabet::const_iterator b; // pour enumerer toutes les lettres + Word w; // Le mot courant + + + w.clear(); // on initialise avec w <-- epsilon + // On ajoute tous les successeurs de v + L.push_back (w); // et L = { eps } + while ((!L.empty ()) && (maxmots != 0)) + { // tant que L n'est pas vide + w = L.front (); + L.pop_front (); // w = min(L) et L=L\{w} + if (W.find(w) == W.end()) { + --maxmots; + W.insert (w); + } + for (b = Sigma.begin (); b != Sigma.end (); b++) + { + w += *b; // w <-- wb + //W.insert(w); + if (S.find (v+w) != S.end ()) // si p_n(w)>0 + { + L.push_back (w); + } + w.erase (--w.end()); //w.pop_back (); // wb <-- w + } + } + + return VAL (0); +} + +// Return the set of word used to construct the inequation system +// (the set W described in the paper in the definition of system I) +RESULT +PPRFA::liste_mots_associes (WordSet &W, + const Word & v, + const Sample & S, + int maxmots) const +{ + map::const_iterator q; // L'etat courant + W.clear (); // on initialise W + // On ajoute tous les successeurs de v + ajoute_mots_associes (W, v, S); + // On ajoute tous les successeurs des elements de R + for (q = XR.begin (); q != XR.end (); q++) + { + ajoute_mots_associes (W, q->first, S, maxmots); + } + return VAL (0); +} + +// renvoie vide si le systËme lineaire I(v,R,S,precision) n'a pas de solution et +// sinon renvoie une solution de I i.e. un ensemble de variables X_q telles que +// v^{-1}P = \sum_{q \in R} X_qP_q -- en rappelant que R[w]=q => P_q = w^{-1}P +// En prenant un maximum de max variables +RESULT PPRFA::solmax (T_ModeVariables modeVariables, + SFunc & solution, // La solution + const Word & v, // Le residuel a tester + const Sample & S, // L'echantillon + Simplex & simplx, // L'objet simplex qui permet de calculer la solution + double precision, // La precision (sa signification depend du mode) + T_ModeReturn moderet, // Le mode de retour : beg debut de l'arbre, end à la fin + T_ModeEpsilon modeeps, // Le mode : epsfixed avec epsilon fixe, variable avec epsilon variable. + WordSet &W, // L'ensemble de mots sur lesquels on teste, + // doit contenirs les mots des étapes prÈcÈdentes + unsigned int max) const +{ + try + { + + // cout << "\t\tcreation du systeme" << endl; + + unsigned int i; + int n; // number of variables + int err; + WordSFunc::const_iterator q; + + // number of variables = number of states + n = XR.size (); + + /* + // ---------- Affichage de la liste de mots utilises -------------- + set::const_iterator wy; + map::const_iterator ri; + int compte = 1; + cout << "\nliste de mots associes à " << v << " et à {"; + for (ri=XR.begin() ; ri != XR.end() ; ri++) { + if (ri->first.empty()) + cout << "eps,"; + else + cout << ri->first << ","; + } + cout << "}" << endl; + for (wy = W.begin() ; wy != W.end() ;wy++) { + if (wy->empty()) + cout << "eps,"; + else + cout << *wy << ","; + if (!(compte++ % 10)) + cout << "\n"; + } + cout << "\nNombre de mots : " << W.size(); + cout << endl; + // -------------------------------------------------------------- + */ + + // avec l'entree 0 on traite tous les mots + if (max == 0) + max = W.size () + 1; + + // inequations en <= (nb=ineq1), inequations en >= (nb=ineq2) + // les inequations X_q >= 0 sont deja + // prisent en comptent de manière implicite + double s1; + double s2; + set< Word, ordre_mot >::const_iterator wi; + + double pvw = 0; // v^{-1}P(w) + + s2 = S[v]; + + // Initialisation du simplexe + simplx.set_number_of_unknown_to(XR.size()+1); + + // sum of all Xi is equal to 1 + simplx.setparam(1,0); // --- la variable 1 est toujours epsilon --- + simplx.setval(1); // + for (q = XR.begin (); q != XR.end (); q++) + simplx.setparam(q->second+1,1); + simplx.add_equality_constraint(); + // cout << "XR.size() = " << XR.size() << endl; + + + // loop for each word : + simplx.setparam(1,1); // --- la variable 1 est toujours epsilon --- + + i=0; + for (wi = W.begin (); wi != W.end () && i <= max; wi++) + { + s1 = S[(v + *wi)]; + pvw = (double) s1 / (double) s2; + simplx.setval(pvw); + for (q = XR.begin (); q != XR.end (); q++) + { + s1 = S[q->first + *wi]; + simplx.setparam(q->second+1, (double) s1 / (double) S[q->first]); + } + simplx.add_absolute_constraint(); + ++i; + } + + + switch (modeeps) + { + // ---------------------------------------------------------- EPSFIXED - + case epsfixed: + simplx.set_minimize_epsilon_mode(precision); + break; + // ---------------------------------------------------------- VARIABLE - + case variable: + simplx.set_minimize_epsilon_mode(-1); + break; + default: + cerr << "!!! PFA::sol -- modeeps " << modeeps << " inconnu !!!" << endl; + } + + switch(modeVariables) { + case determinist: + simplx.set_mode(ZeroOrOne); + break; + case positive: + simplx.set_mode(realZeroBounded); + break; + case nonconstrained: + simplx.set_mode(realNotBounded); + break; + } + + map preciseSol; + float epsilon; + // simplx.affiche(); + err = simplx.has_solution(preciseSol, epsilon); + // cout << (err?"solution trouvée":"pas de solution") << ", epsilon = " << epsilon << endl; + if ((!err) || (epsilon>precision)) { + solution.clear(); + return ERR(0); + } + else { + solution.clear(); + float tmp; + for (map::const_iterator q = preciseSol.begin() ; q != preciseSol.end() ; q++) { + if (q->first != 1) { + if ((tmp = (float) q->second) != 0) { + solution[q->first - 1] = (float) q->second; + } + } + } + return VAL(0); + } + } + catch (int erreur) + { + if (PFA_VERBOSE) + { + cerr << "ERREUR !!! PFA::solmax !!! n°" << erreur << endl; + } + solution.clear (); + return erreur; + } +} + + + + +// renvoie vide si le système lineaire I(v,R,S,precision) n'a pas de solution et +// sinon renvoie une solution de I i.e. un ensemble de variables X_q telles que +// v^{-1}P = \sum_{q \in R} X_qP_q -- en rappelant que R[w]=q => P_q = w^{-1}P +RESULT PPRFA::sol (T_ModeVariables modeVariables, // le mode dans lequel renvoyer les variables + SFunc & solution, // La solution + const Word & v, // Le residuel a tester + const Sample & S, // L'echantillon + Simplex & simplx, // L'objet simplex qui permet de calculer la solution + double precision, // La precision (sa signification dépend du mode) + T_ModeReturn moderet, // Le mode de retour : beg debut de l'arbre, end à la fin + T_ModeEpsilon modeeps, // Le mode : epsfixed avec epsilon fixe, variable avec epsilon variable. + WordSet &W, // L'ensemble de mots sur lesquels on teste, + // doit contenirs les mots des étapes précédentes + int maxmots, // le nombre de mots qu'on ajoute au maximum + bool Wcalculated // true if W is considered as calculated from outside + ) const +{ + // unsigned int n = 2 * Q.size () + 1; + + // - Pour connaitre le nombre d'inequation, on doit + // - connaitre le nombre de mots qui sont successurs de v, et de tous + // - les ÈlÈments de R. + // - On met l'ensemble des successeurs de v et des éléments de R de l'echantillon dans W. + + if (!Wcalculated) + { + ajoute_mots_associes (W, v, S, maxmots); + } + //liste_mots_associes(W,v,S,(int)((float)S.size()/(float)XR.size())); + return solmax (modeVariables,solution, v, S, simplx,precision, moderet, modeeps, W, INT_MAX); + +/* + solret = solmax (modeVariables, solution, v, S, simplx, precision, moderet,modeeps, W, n); + if ( !solret || (n >= W.size ())) + return err; + else + { + n *= 5; + solret = solmax (modeVariables, solution, v, S, simplx, precision,moderet, modeeps, W, n); + if (!solret || (n >= W.size ())) + return err; + else + return solmax (modeVariables,solution, v, S, simplx,precision, moderet, modeeps, W, INT_MAX); + } + */ +} \ No newline at end of file diff --git a/sample.H b/sample.H new file mode 100644 index 0000000..55eb8e8 --- /dev/null +++ b/sample.H @@ -0,0 +1,203 @@ +/*************************************************************************** + echantillon.h - Sample de mots + ------------------- + begin : 20 Jan 2003 + copyright : (C) 2003 by Yann Esposito + email : esposito@cmi.univ-mrs.fr +***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + +***************************************************************************/ + +/*_________________________________________________________________________*\ + Classe échantillon, échantillon de mots. + \***************************************************************************/ + +#ifndef ECHANTILLON_H +#define ECHANTILLON_H + +// le type de sortie +typedef enum {ffa, alergia, mdi} T_Format; + +#include "general.H" +#include +// ----------------------- Declaration --------------------------------- +// ordre naturel sur les mots +struct ordre_mot +{ + bool operator()(const Word u, const Word v) const + { + if (u.size() < v.size()) + return true; + else if (u.size() > v.size()) + return false; + else + { + less infeq; + return infeq(u,v); + } + } +}; + +// Type echantillon qui suit l'ordre naturel sur les mots +typedef map EnsWord; // Le type ensemble de mots + +// ------------------------ La Classe ---------------------------------- +class Sample +{ +protected: + Alphabet Sigma; // Ensemble de lettre de l'echantillon + Dictionnaire alph; // permet d'associer des éléments plus complexes aux lettres. + EnsWord S; // l'ensemble de mots + unsigned int taille; // la taille de l'echantillon + bool prefixiel; // vrai si l'echantillon est prefixiel. +public: + int seuil; // Le seuil à partir duquel on permet de visualiser un élément de l'échantillon + +public: + + // --- Constructeur et Destructeurs --- + Sample() : taille(0), seuil(0) + {} + Sample(const Alphabet A, const Dictionnaire D, const bool pref=false, int n_seuil=0) : + Sigma(A), alph(D), taille(0), prefixiel(pref), seuil(n_seuil) + {} + ~Sample(void) + {} + + // --- Les accesseurs --- + // Renvoie le nombre de fois qu'est present le mot w + inline unsigned int count(const Word w) const + { + EnsWord::const_iterator s; + s = S.find(w); + return (s!=S.end())?s->second:0; + } + inline unsigned int operator[](const Word w) const + { + return count(w); + } + // Renvoie la taille de l'echantillon + inline unsigned int size() const + { + return taille; + } + // Renvoie l'alphabet de l'echantillon + inline Alphabet alphabet() const + { + return Sigma; + } + // Renvoie le dictionnaire + inline Dictionnaire dictionnaire() const + { + return alph; + } + // Renvoie l'ensemble de mot + inline EnsWord ensWord() const + { + return S; + } + // Renvoie le nombre de mots contenus dans S (pour la fct° precision) + inline unsigned int nb_mots() const + { + return S.size(); + } + // Renvoie alph + inline Dictionnaire get_alph() const + { + return alph; + } + + // Revoie vrai si l'echantillon est prefixiel + inline bool isprefixiel() const + { + return prefixiel; + } + + // iterateurs + typedef EnsWord::const_iterator const_iterator; + inline const_iterator begin() const + { + return S.begin(); + } + inline const_iterator end() const + { + return S.end(); + } + inline const_iterator find(Word w) const + { + EnsWord::const_iterator u=S.find(w); + return ((u!=S.end()) && (u->second >= seuil))?u:S.end(); + } + +public: + // renvoie le prochain iterateur pointant vers un mot apparaissant + // un nombre supérieur de fois au seuil. + inline void next(const_iterator &w) const + { + do + w++; + while ((w->second < seuil) && (w != S.end())); + } + + // --- Les méthodes --- + // Ajout une lettre par defaut à l'alphabet + Lettre addLettre(const Lettre l); + // Ajout de la lettre specifiee à l'alphabet + Lettre addLettre(const string l); + // Ajout de la lettre specifie a l'alphabet c etant la lettre associe pour les mots + Lettre addLettre (const Lettre c, const string l); + // Insere le mot w, si safe est vrai, on met à jour l'alphabet et le dictionnaire. + RESULT insert(const Word w, const unsigned int num=1, const bool safe=true); + // Rend l'echantillon vide + RESULT vide(); + inline RESULT clear() + { + return vide(); + }; + // Sauvegarde l'echantillon dans le fichier Filename + RESULT save(const char *Filename, T_Format format=ffa) const; + inline RESULT save(const string Filename, T_Format format=ffa) const + { + return Sample::save(Filename.c_str(), format); + } + // Charge l'echantillon à partir d'un fichier + RESULT load(const char *Filename); + inline RESULT load(const string Filename) + { + return load((char *)Filename.c_str()); + } + // Prefixialise l'echantillon + RESULT prefixialise(); + // Deprefixialise l'echantillon + RESULT deprefixialise(); + // Suppression des valeurs inferieures au seuil + inline RESULT seuille(const int n_seuil) + { + return seuil = n_seuil; + } + // Sépare un échantillon en un échantillon principal et un échantillon test + int separe(Sample &Stest, const float proportion); + // Ajoute un échantillon à un autre + Sample &operator+=(const Sample &Stest); + + // return the likelihood of the MLM + float AutoLikelihood() const; + + // return the list of words successor of v (in the prefixial sample) + Sample prefix_successor_of(const Word &v) ; + // return words begining by v + Sample begin_by(const Word &v); + // become S inter S2 + void inter(const Sample &S2); + +}; + +#endif diff --git a/sample.cpp b/sample.cpp new file mode 100644 index 0000000..04d790b --- /dev/null +++ b/sample.cpp @@ -0,0 +1,762 @@ +/*************************************************************************** + echantillon.C + ------------------- + begin : 20 Jan 2003 + copyright : (C) 2003 by Yann Esposito + email : esposito@cmi.univ-mrs.fr +***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +/* + Pour les notes, voir le fichier "echantillon.h". + See "echantillon.h" file to view notes. +*/ +#include "sample.H" +#include + +// Ajout une lettre par defaut à l'alphabet +Lettre Sample::addLettre (const Lettre l) +{ + Lettre a; + if (!Sigma.empty ()) + { + a = *(--(Sigma.end ())) + 1; + } + else + { + a = 'a'; + } + Sigma.insert (a); + alph[a] = l; + return a; +} + +// Ajout de la lettre spécifiée à l'alphabet +Lettre Sample::addLettre (const string l) +{ + Lettre a; + if (!Sigma.empty ()) + { + a = *(--(Sigma.end ())) + 1; + } + else + { + a = 'a'; + } + Sigma.insert (a); + alph[a] = l; + return a; +} + +// Ajout de la lettre specifiee a l'alphabet +Lettre Sample::addLettre (const Lettre c, const string l) +{ + Sigma.insert (c); + alph[c] = l; + return c; +} + +// Insere num fois le mot w +RESULT Sample::insert (const Word w, + const unsigned int num, + const bool safe) +{ + if (safe) + { + // on verifie si le mot contient des lettres en plus + Word::const_iterator a; + for (a = w.begin (); a != w.end (); a++) + { + if (Sigma.find (*a) == Sigma.end ()) + { + addLettre (*a); + } + } + } + + if (prefixiel) + { + Word u; + Word::const_iterator a; + u.clear (); + for (a = w.begin (); a != w.end (); a++) + { + u += *a; + S[u] += num; + } + } + else + { + S[w] += num; + } + + taille += num; + + return VAL (0); +} + +// Rend l'echantillon vide +RESULT Sample::vide () +{ + S.clear (); + Sigma.clear (); + alph.clear (); + taille = 0; + prefixiel = false; + return VAL (0); +} + +// Sauvegarde un echantillon dans le fichier Filename +RESULT Sample::save (const char *Filename, T_Format format) const +{ + try + { + if (Filename == NULL) + throw -1; + ofstream + fp (Filename); + if (!fp.good ()) + throw -2; + + EnsWord::const_iterator w; + Word::const_iterator l; + Dictionnaire::const_iterator a; + string msg; + int i; + + switch (format) + { + case ffa: // ========================= format ffa ============================= + // Affichage de l'entete + fp << "Sample" << endl; // Affichage de Sample + // Affichage de la taille + fp << "Taille " << size () << endl; + // ---- ne pas modifier l'ordre Nb_Lettre puis Alphabet pour le "load" --- + // Affichage du nombre de lettres + fp << "Nb_Lettres " << alph.size () << endl; + // Affichage de l'alphabet + fp << "Alphabet" << endl; + for (a = alph.begin (); a != alph.end (); a++) + { + fp << a->first << " " << a->second << "\n"; + } + fp << endl; + // Affichage du drapeau prefixiel + fp << "Prefixiel " << prefixiel << endl; + // Affichage de l'echantillon proprement dit + for (w = S.begin (); w != S.end (); w++) + { + for (l = w->first.begin (); + l != w->first.end (); l++) + { + fp << alph.find (*l)-> + second << " "; + } + fp << ": " << w->second; + fp << endl; + } + break; + + case alergia: // format alergia + for (w = S.begin (); w != S.end (); w++) + { + msg=""; + for (l = w->first.begin (); l != w->first.end (); l++) + { + msg += alph.find (*l)->second; + } + for (i = 0; i < w->second; i++) + fp << msg << endl; + } + break; + + case mdi: // format MDI + for (w = S.begin (); w != S.end (); w++) { + msg.clear (); + for (l = w->first.begin (); l != w->first.end (); l++) { + msg += alph.find(*l)->second; + msg += " "; + } + for (i = 0; i < w->second; i++) { + fp << msg << endl; + } + } + break; + + default: + cerr << "Sample::save()" << endl; + cerr << "Format " << format << "inconnu !!!" << + endl; + throw - 3; + } + return VAL (0); + } + catch (int e) + { + if (PFA_VERBOSE) + { + cerr << " PFA::echantillon(int taille, char *Filename)" << endl; + switch (e) + { + case -1: + cerr << " : Filename = NULL !!!" << endl; + break; + case -2: + cerr << "Impossible d'ecrire dans le fichier '" << Filename << "' !!!" << endl; + default: + cerr << "Unknown error" << endl; + } + } + return e; + } + catch (...) + { + cerr << " PFA::echantillon(int taille, char *Filename)" + << endl; + cerr << "Unknown error !!!" << endl; + return -1; + } +} + +// Charge un echantillon +RESULT Sample::load (const char *Filename) +{ + // les échantillons sont sous la forme d'un liste de lignes + // mot : nb_apparitions + try + { + // on verifie qu'il n'y ai pas une erreur du passage du nom + if (Filename == NULL) + throw - 1; + ifstream + fp (Filename); // on declare le descripteur de fichier et on l'ouvre + // on verifie qu'il n'y ait pas d'erreur d'ouverture + if (!fp.good ()) + throw - 2; + + + Word w; // le mot + map < string, Lettre > inv_alph; // le dictionnaire inversé + int i; + int nb_lettres; + bool safe; // des drapeaux fin de fichier et mode safe + char c; + string buf; // le buffer + + // on vide la structure + vide (); + + fp >> buf; // on lit le premier mot + if (buf == "Sample") + { // ========================== TYPE de fichier echantillon interne = + + safe = true; + // Tant que l'on est pas à la fin du fichier + while (!fp.eof ()) + { // boucle principale + fp >> buf; + if (buf == "%") + { // -------------------- Commentaire + while ((fp.good ()) && (c != '\n')) + { + fp >> c; + } + } + else if (buf == "Taille") + { // ------- Taille de l'echantillon + fp >> taille; // on lit la taille + } + else if (buf == "Nb_Lettres") + { // --- On lit l'alphabet + fp >> nb_lettres; // on lit le nombre de lettres + fp >> buf; + if (buf != "Alphabet") + throw - 3; + Lettre c; + for (i = 0; (i < nb_lettres) && (fp.good ()); i++) + { + fp >> c; + fp >> buf; // on lit la lettre + addLettre (c,buf); + } + Dictionnaire::iterator x; + for (x = alph.begin (); + x != alph.end (); x++) + { + inv_alph[x->second] = + x->first; + } + safe = false; // pas besoin d'etre en mode safe pour le chargement de l'echantillon + } + else if (buf == "Prefixiel") + { // ------ On regarde si l'echantillon est prefixiel + fp >> prefixiel; // on lit la valeur du drapeau "prefixiel" + } + else + { // ------------------- On charge les données + while (fp.good ()) + { + // on lit le mot + w.clear (); + while ((fp.good ()) + && (buf != ":")) + { + if (safe) + { // si on ne connait pas l'alphabet, on verifie l'arrivee de nouvelles lettres. + if (inv_alph. + find (buf) + == + inv_alph. + end ()) + { + inv_alph[buf] = addLettre (buf); + } + } + w += inv_alph. + find (buf)-> + second; + // w.push_back(inv_alph.find(buf)->second); + fp >> buf; // on lit la prochaine lettre. + } + // on a fini de lire le mot + if (fp.good ()) + fp >> S[w]; // on lit le nombre de fois qu'est apparu ce mot. + fp >> buf; + } + } + } + return VAL (0); + } + else if (buf == "Text_without_space") + { // ================================ Mode mots (alergia et mdi)- + w.clear (); // on initialise le mot courant. + prefixiel = false; + fp.get(c); // on lit le caractere '\n' + while (!fp.eof()) + { + fp.get(c); + // on ajoute si nécessaire les nouvelles lettres + if ((c != '\n') && (c != '\t') && (c != ' ')) // on lit une nouvelle lettre + { + if (Sigma.find (c) == Sigma.end ()) // si c \notin Sigma + { + Sigma.insert (c); + alph[c] = c; + } + w += c; // on ralonge le mot + } else // on est a la fin de la phrase + { + ++S[w]; // on ajoute le mot un coup + w.clear(); // et on le réinitialise + } + } + + // on supprime l'artefact pour epsilon + w.clear(); + --S[w]; + if (S.begin()->second == 0) + S.erase(S.begin()); + + EnsWord::iterator wi; + taille=0; + for (wi=S.begin() ; wi != S.end() ; ++wi) + { + taille += wi->second; + } + + return VAL (0); + } + else if (buf == "Text_with_spaces") + { // ========================== mode phrases --- + //caractere de separation : . + Word curmot; + Lettre curlettre = 'a'; + + curmot.clear (); + prefixiel = false; + Dictionnaire::const_iterator d; + while (fp.good ()) + { + bool findephrase=false; + fp >> buf; // on lit la premiere lettre (un mot) + // cout << "lettre : " << buf << flush; + c = *(buf.rbegin ()); // c is the last letter of the string buf + if ((c == '.') || (c == '!') || (c='?')) { + buf.erase(--buf.end()); + findephrase=true; + } + // on cherche a savoir si on a deja insere w + for (d = alph.begin ();(d != alph.end ()) && (d->second != buf); d++) + ; + if (d == alph.end ()) + { + // cout << ": jamais vue." << endl; + Sigma.insert (curlettre); + alph[curlettre] = buf; + curmot += curlettre; + ++curlettre; + } + else + { + // cout << ": deja vue." << endl; + curmot += d->first; + } + c = *(buf.rbegin ()); // c is the last letter of the string buf + if (findephrase) + { + // si on arrive en fin de phrase + cout << "fin de la phrase : " << endl; + for (Word::const_iterator mi = curmot.begin() ; mi != curmot.end() ; ++mi) + cout << alph[*mi] << " "; + cout << endl; + ++S[curmot]; + ++taille; + curmot.clear (); + findephrase=false; + } + } + return VAL (0); + } + else if (buf == "Amaury") + { // ========================== mode phrases pour Amaury --- + //caractere de separation : . + Word curmot; + // Lettre curlettre = 'a'; + + curmot.clear (); + prefixiel = false; + Dictionnaire::const_iterator d; + while (fp.good ()) + { + ++S[curmot]; + ++taille; + curmot.clear (); + } + return VAL (0); + } + else + throw - 4; + } + catch (int e) + { + if (PFA_VERBOSE) + { + cerr << " Sample::load(char *Filename)" << endl; + switch (e) + { + case -1: + cerr << "Filename = NULL !!!" << endl; + break; + + case -2: + cerr << Filename << "is unreadable !!!" << + endl; + break; + + case -3: + cerr << "Erreur de coherence lors du chargement du fichier :" << Filename << endl; + cerr << "\"Nb_Lettres\" n'est pas suivit d'un chiffre puis de \"Alphabet\"" << endl; + break; + + case -4: + cerr << "Format of the file " << Filename << + " is not recognized" << endl; + cerr << "Add 'Text_without_space' or 'Text_with_spaces' at the begining of the file" << endl; + cerr << "to make the file in a valid format." + << endl; + break; + + default: + cerr << "Erreur non repertoriée" << endl; + } + } + return e; + } + catch (...) + { + cerr << "Sample::load() Erreur non repertoriee et non traitee" << endl; + return -1; + } +} + +// Genere l'echantillon prefixe associe à l'échantillon non prefixe S. +RESULT Sample::prefixialise () +{ + if (!prefixiel) + { + Word u; + Word::const_iterator a; // la lettre courante + EnsWord::const_iterator w; // le mot courant + EnsWord Spref; // l'echantillon prefixe + + u.clear (); + Spref[u] = taille; + for (w = S.begin (); w != S.end (); ++w) + { + u.clear (); + for (a = w->first.begin (); a != w->first.end (); ++a) + { + u += *a; + Spref[u] += w->second; + } + } + S = Spref; + prefixiel = true; + + return VAL (0); + } + else + { + return ERR (0); + } +} + +// Deprefixialise +RESULT Sample::deprefixialise () +{ + if (!prefixiel) + { + return VAL (1); + } + else + { + EnsWord R; + EnsWord::const_iterator w, u; + Alphabet::const_iterator a; + int sum; + for (w = S.begin (); w != S.end (); w++) + { + sum = 0; + for (a = Sigma.begin (); a != Sigma.end (); a++) + { + u = S.find (w->first + *a); + if (u != S.end ()) + sum += u->second; + } + if (w->second != sum) { + R[w->first] = w->second - sum; + } + } + S = R; + prefixiel = false; + return VAL (0); + } +} + +// Sépare un échantillon en un échantillon principal et un échantillon test +int +Sample::separe (Sample & Stest, const float proportion) +{ + deprefixialise(); + Stest.clear(); + Stest.alph=alph; + Stest.Sigma=Sigma; + int nb_suppr = int(float(taille) * proportion); + int num; + EnsWord::iterator w; + + while (nb_suppr-- != 0) { + w=S.begin(); + num = int(float(rand ())*float(taille) / float(INT_MAX)); + num -= w->second; + while (num > 0) { + w++; + num -= w->second; + } + Stest.insert( w->first ); + if (--(w->second) == 0) { + S.erase(w); + } + --taille; + } + + return Stest.size(); + + + + //~ deprefixialise (); + //~ EnsWord::iterator w; + //~ int i; + //~ int nb_suppr; + //~ Stest.clear (); // first we clear the test sample + //~ Stest.alph = alph; + //~ Stest.Sigma = Sigma; + + //~ for (w = S.begin (); w != S.end (); ++w) + //~ { + //~ nb_suppr = 0; + //~ for (i = 0; i < w->second; ++i) + //~ { + //~ float val; + //~ val = (float) ((float) random () / (float) INT_MAX); + //~ if (val < proportion) + //~ { + //~ Stest.insert (w->first); + //~ ++nb_suppr; + //~ } + //~ } + //~ w->second -= nb_suppr; + //~ taille -= nb_suppr; + //~ } + //~ // Suppression des mots effaces de l'echantillons + //~ EnsWord::iterator wtmp; + //~ for (w = S.begin (); w != S.end (); ++w) + //~ { + //~ if (w->second == 0) + //~ { + //~ wtmp = w; + //~ ++wtmp; + //~ S.erase (w); + //~ w = wtmp; + //~ } + //~ } + //~ return Stest.size (); +} + +// Ajoute un échantillon à un autre +Sample & Sample::operator+= (const Sample & Stest) +{ + // if (alph != Stest.alph) throw 1; + Sample::const_iterator w; + for (w = Stest.begin (); w != Stest.end (); ++w) + insert (w->first, w->second); + return *this; +} + +float Sample::AutoLikelihood() const +{ + if (prefixiel) + { + cerr << "Sample::AutoLikelihood() : echantillon prefixiel !" << endl; + return -1; + } + + Sample::const_iterator w; + unsigned int si = size(); + float result=0; + for (w=begin() ; w != end() ; ++w) + { + result += (log ( float(w->second) / float(si) )) * w->second; + } + return result; +} + +Sample Sample::begin_by(const Word &v) { + bool waspref=prefixiel; + if (!prefixiel) { + prefixialise(); + } + + list W; + Sample X; + Word u; + + X.Sigma=Sigma; + X.alph=alph; + X.prefixiel=true; + + EnsWord::const_iterator w; + w=S.find(v); + if (w != S.end()) { + W.push_back(w->first); + X.S[w->first]=w->second; + } + + Alphabet::const_iterator a; + while (!W.empty()) { + u=*(W.begin()); + W.pop_front(); + for (a=Sigma.begin() ; a!=Sigma.end() ;++a) { + u+=*a; + w=S.find(u); + if (w != S.end()) { + W.push_back(w->first); + X.S[w->first]=w->second; + } + u.erase(--u.end()); + } + } + + X.deprefixialise(); + + for (w=X.S.begin() ; w != X.S.end() ; ++w) { + X.taille += w->second; + } + + if (!waspref) { + deprefixialise(); + } + + return X; +} + +Sample Sample::prefix_successor_of(const Word &v) { + bool waspref=prefixiel; + if (!prefixiel) { + prefixialise(); + } + + list W; + Sample X; + Word u; + if (S.find(v) != S.end()) { + W.push_back(u); X.insert(u); + } + + Alphabet::const_iterator a; + while (!W.empty()) { + u=*(W.begin()); W.pop_front(); + for (a=Sigma.begin() ; a!=Sigma.end() ;++a) { + u+=*a; + if (S.find(v+u) != S.end()) { + W.push_back(u); + X.insert(u); + } + u.erase(--u.end()); + } + } + + if (!waspref) { + deprefixialise(); + } + + return X; +} + + +void Sample::inter(const Sample &S2) { + Sample::const_iterator u; + EnsWord::iterator w; + for (w = S.begin() ; w != S.end() ; ++w) { + w->second = 0; + } + for (w = S.begin() ; w!=S.end() ; ++w) { + u=S2.find(w->first); + if (u != S2.end()) { + w->second = u->second; + } + } + + // erase for iota + EnsWord::iterator stmp; + for (w=S.begin() ; w != S.end() ; ) + { + if (w->second == 0) + { + stmp = w; + ++stmp; + S.erase (w); + w = stmp; + } + else + ++w; + } +} diff --git a/simplex.H b/simplex.H new file mode 100644 index 0000000..106def3 --- /dev/null +++ b/simplex.H @@ -0,0 +1,77 @@ +/* + * simplex.H + * dees + * + * Created by Yann Esposito on 17/04/06. + * Copyright 2006 __MyCompanyName__. All rights reserved. + * + */ + +#include "general.H" // pour l'utilisation des map, hash_map... +#include "include/lp_lib.h" + +typedef enum _simplexMode {realNotBounded, realZeroBounded, ZeroOrOne} simplexMode; + +// this is a class used as a wrapper to other libraries +class Simplex { +private: + int n; // number of constraints + lprec *lp; // the linear programming variable (LP_SOLVE) + double *tmpbuf; // temporary buffer used to fill the problem + int tmpbufsize; // size of tmpbuf + double val; // temporary value for equations + + void resize_tmpbuf(void); // update the size of tmpbuf + +public: + Simplex(void) { + lp = NULL; + tmpbuf = NULL; + tmpbufsize=0; + n = 0; + val=0; + } + ~Simplex(void) { + if (lp != NULL) + free_lp(&lp); + if (tmpbuf != NULL) + free(tmpbuf); + } + + // print the linear system + inline void affiche(void) { print_lp(lp); } + + // set the mode for the variables ({0,1}, or Q+ or Q) + int set_mode(const simplexMode newMode); + + // set the nuber of constraints + inline lprec *set_number_of_unknown_to(const int newNumber) { + if (lp != NULL) + free(lp); + n = newNumber; + lp=make_lp(0,n); + if (lp) + set_verbose(lp,0); + + return (lp); + } + + int setval(double newval); + int setparam(int variable, double val); + int add_absolute_constraint(); // use the current values setted by setval and setparam + int add_equality_constraint(); + int add_equality_constraint_with_parameters(double *constraints, double val); + + // add a constraint of the form : + // | constraints[0]X0 + ... + constraints[n-1]Xn-1 - val| <= epsilon + int add_absolute_constraint_with_parameters(double *constraints, double val); + int add_absolute_constraint_with_parameters(const vector constraints, double val); + int add_absolute_constraint_with_parameters(const map constraints, double val); + + // return the solution int the map solution + bool has_solution(map &solution, float &epsilon); + // renvoie 0 si + int set_minimize_epsilon_mode (double epsilon = -1); + +}; + diff --git a/simplex.cpp b/simplex.cpp new file mode 100644 index 0000000..b2e389a --- /dev/null +++ b/simplex.cpp @@ -0,0 +1,196 @@ +/* + * simplex.cpp + * dees + * + * Created by Yann Esposito on 17/04/06. + * Copyright 2006 __MyCompanyName__. All rights reserved. + * + */ + +#include "simplex.H" + +#include "include/lp_lib.h" +#include + +// set the mode for the variables ({0,1}, or Q+ or Q) +int Simplex::set_mode(const simplexMode newMode) { + switch (newMode) { + set_lowbo(lp,1,0.0); // pour epsilon c'est toujours 0 + set_upbo(lp,1,-log(0.0)); // pour epsilon c'est toujours 1 + set_int(lp,1,FALSE); // toujours real + case realNotBounded: + for (int i=2 ; i<=n ; i++) { + set_int(lp,i,FALSE); + set_lowbo(lp,i,log(0.0)); + set_upbo(lp,i,-log(0.0)); + } + break; + case realZeroBounded: + for (int i=2 ; i<=n ; i++) { + set_int(lp,i,FALSE); + set_lowbo(lp,i,0); + set_upbo(lp,i,-log(0.0)); + } + break; + case ZeroOrOne: + for (int i=2 ; i<=n ; i++) { + set_binary(lp,i,TRUE); + } + break; + default: + cerr << "Simplex::set_mode : mode inconnu : " << newMode << endl; + throw -1; + } + return VAL(0); +} + + +// add a equality constraint of the form : +// tmpbuf[1]X1 + tmpbuf[2]X2 + ... + tmpbuf[n]Xn = val +// One can view X1 as an epsilon value +int Simplex::add_equality_constraint() { + return add_equality_constraint_with_parameters(tmpbuf,val); +} + + +// add a equality constraint of the form : +// constraints[1]X1 + constraints[2]X2 + ... + constraints[n]Xn = val +// One can view X1 as an epsilon value +int Simplex::add_equality_constraint_with_parameters(double *constraints,double val) { + set_add_rowmode(lp,TRUE); + add_constraint(lp,constraints,EQ,val); + set_add_rowmode(lp,FALSE); + return 0; +} + + +int Simplex::add_absolute_constraint(void) { + return add_absolute_constraint_with_parameters(tmpbuf,val); +} + +// add a constraint of the form : +// | constraints[2]X2 + ... + constraints[n]Xn - val | <= constraints[1]*X1 +// One can view X1 as an epsilon value +int Simplex::add_absolute_constraint_with_parameters(double *constraints,double val) { + set_add_rowmode(lp,TRUE); + if (constraints[1] != 1) { + cerr << "WARNING !!!! add_absolute_constratins_with_parameters\n"; + cerr << "constraints[n] should be 1 and it is " << constraints[n] << endl; + } + // constraint of the form + // constraints[1]X1 + ... + constraints[n]Xn >= -val + add_constraint(lp,constraints,GE,val); + // constraint of the form + // -constraints[1]X1 + ... + constraints[n]Xn <= -val + constraints[1] = -constraints[1]; + add_constraint(lp,constraints,LE,val); + constraints[1] = -constraints[1]; + set_add_rowmode(lp,FALSE); + return 0; +} + +int Simplex::add_absolute_constraint_with_parameters(const vector constraints, double val) { + resize_tmpbuf(); + vector::const_iterator i; + int j; + for (i=constraints.begin(), j=2 ; i!=constraints.end() ; i++, j++) { + tmpbuf[j]=*i; + } + tmpbuf[1]=1; + return add_absolute_constraint_with_parameters(tmpbuf,val); +} + +int Simplex::add_absolute_constraint_with_parameters(const map constraints, double val) { + resize_tmpbuf(); + map::const_iterator i; + for (i=constraints.begin() ; i!=constraints.end() ; i++) { + tmpbuf[i->first]=i->second; + } + tmpbuf[1]=1; + return add_absolute_constraint_with_parameters(tmpbuf,val); +} + +// set minimize epsilon mode or fixed epsilon mode +// if epsilon < 0 then minimize epsilon +// else fix the epsilon value +int Simplex::set_minimize_epsilon_mode (double epsilon) { + resize_tmpbuf(); + for (int i=1;i<=n+1;i++) { + tmpbuf[i]=0; + } + // tmpbuf = 0 0 ... 0 + if (epsilon < 0) { // minimize the value of epsilon + tmpbuf[1]=1; + set_obj_fn(lp,tmpbuf); + set_minim(lp); // minimize the objective function + } else { + set_add_rowmode(lp,TRUE); + set_obj_fn(lp,tmpbuf); // minimize the 0 function + set_minim(lp); + tmpbuf[1]=1; + add_constraint(lp,tmpbuf,EQ,epsilon); // add the constraint epsilon = given value + set_add_rowmode(lp,FALSE); + } + return VAL(0); +} + + +// répond oui ou non, il y a une solution +bool Simplex::has_solution(map &solution, float &epsilon) { + int res = solve(lp); + // print_lp(lp); + int temp ; + if ((res == 0) || + (res == 1) || + (res == 3) || + (res == 4) || + (res == 12) ) { + temp = 2 + get_Nrows(lp) ; + if (tmpbufsize < temp + n ) { + if (tmpbufsize > 0) { + free(tmpbuf); + } + tmpbuf = new double [ temp + n ]; + tmpbufsize = temp + n; + } + + get_primal_solution(lp,tmpbuf); + epsilon = tmpbuf[0]; + for (int i=1 ; i<= n ; i++) { + solution[i]=(float)tmpbuf[temp + i -2]; + } + return true; + } + else { + solution.clear(); + return false; + } +} + + +int Simplex::setval(double newval) { + val = newval; + return VAL(0); +} + +void Simplex::resize_tmpbuf(void) { + if (tmpbufsize < n + 2) { + if (tmpbuf != NULL) + free(tmpbuf); + tmpbuf = new double[2*n+2]; + tmpbufsize=2*n+2; + } +} + +int Simplex::setparam(int variable, double val) { + resize_tmpbuf(); + if (PFA_SAFE) { + if ((variable<1) || (variable>n+1)) { + cerr << "Aie Aie Aie !!! Simplex::setparam called with variable = " << variable << " where max should be "; + cerr << n-1 << " !!! " << endl; + } + } + tmpbuf[variable]=val; + return VAL(0); +} + diff --git a/spfa.H b/spfa.H new file mode 100644 index 0000000..cfc33a7 --- /dev/null +++ b/spfa.H @@ -0,0 +1,168 @@ +/*************************************************************************** + spfa.h - Semi-Probabilistic Finite Automaton + ------------------- + begin : 7 Dec 2002 + copyright : (C) 2002 by Yann Esposito + email : esposito@cmi.univ-mrs.fr + *************************************************************************** + + *************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + *************************************************************************** + + ____________ HISTORIQUE et Déscription plus précise _____________________ + +Classe qui hérite de la classe ffa, la seule différence est que les +valeurs de iota, phi et tau doivent être positives et +sum_{q} iota[q]=1. + +pour tout etat q : tau[q] + sum_{a,r} phi[q][a][r] = 1 + _________________________________________________________________________ +*/ + +#ifndef SPFA_H +#define SPFA_H + +#include "ma.H" +#include "sample.H" +#include + + +typedef map WordSFunc; +typedef map StateSFunc; +typedef map StateWordFunction; +typedef set WordSet; + + +class SPFA : public MA +{ +public : + + // Ajoute un état + //RESULT addState(const float init=0, const float term=1); + RESULT addNewState (const float init, const float term); + // Fonction qui ajoute une transition + RESULT addTransition(const Transition &t, const float val); + // Ajout d'une transition + RESULT addTransition(const State qdep, const Lettre a, const State qarr, const float val); + + RESULT becomeRandom(const int num_etat, // le nombre d'états + const int num_lettre, // le nombre de lettres + const int num_graphe = 0, // le numero du graphe + const float densite=0.3, // densité du ffa (0 ffa vide, 1 ffa complet) + const float prob_init=0.3, // la probabilité pour un état d'etre initial + const float prob_term=0.3, // probabilité pour un état d'être terminal + const float min_trans = 0, // la valeur minimale des transitions + const float max_trans = 1); // la valeur maximale des transitions + + RESULT becomeRandomPrefix(const int nb_etats, // le nombre d'états + const int nb_lettres, // le nombre de lettres + const int num_graphe = 0, // le numero du graphe + const float densite=0.3, // densité du ffa (0 ffa vide, 1 ffa complet) + const float prob_init=0.3, // la probabilité pour un état d'etre initial + const float prob_term=0.3, // probabilité pour un état d'être terminal + const float min_trans = 0, // la valeur minimale des transitions + const float max_trans = 1); // la valeur maximale des transitions + + // Cree un MA aleatoire avec un nombre maximal d'aretes + RESULT becomeRandomMax (const int nb_etats, const int nb_lettres, + const int num_graphe, const int nb_succ, + const int nb_init, const int nb_term, + const float min_trans, const float max_trans); + + // --- Output methods --- +protected: + // log (exp(p1) + exp(p2)) = p1 + log(1 + exp(p2-p1)) pour p1 > p2 + // good approximation if p1=log(x1) and p2=log(x2) sumlog(p1,p2) return a good approximation + // of log(x1 + x2) + inline double sumlog(const double p1, const double p2) const + { + return (p1>p2)?(p1 + log(1+exp(p2-p1))):(p2 + log(1+exp(p1-p2))); + } +public: + // extension of the phi function to words + inline double phiext(const State q, const Word &u, const State s, const Dictionnaire *dico=NULL) const + { + return exp(philog(q,u,s,dico)); + } + // logarith of the extended phi + double philog(const State q, const Word &u, const State s, const Dictionnaire *dico=NULL) const; + // la fonction p renvoie la valeur d'un mot (probabilité dans les PFAs) + inline double p(const Word &u, const Dictionnaire *dico=NULL) const + { + return exp(plog(u,dico)); + } + // le logarithme de la fonction p + double plog(const Word &u, const Dictionnaire *dico=NULL) const; + + // la fonction p calculŽe de faon directe !!! ATTENTION AUX ARRONDIS !! + double p_directe(const Word &u, const Dictionnaire *dico=NULL) const; + + + // probability to be in state q having read the word u + inline double p(const State q, const Word &u, const Dictionnaire *dico=NULL) + { + return exp(plog(q,u,dico)); + } + // logarithm of the probability to be in state q having read the word u + double plog(const State q, const Word &u, const Dictionnaire *dico=NULL) const; + + // return probability to begin by u + double p_bar(const Word &u, const Dictionnaire * dico=NULL) const; + // return probability to begin by u without log trick + double p_bar_directe(const Word &u, const Dictionnaire * dico=NULL) const; + // return the log probability to begin by u + double plog_bar(const Word &u, const Dictionnaire * dico=NULL) const; + + // return the forward vector + RESULT logforward(PreciseSFunc &F, const Word &u) const; + RESULT logforwardprecalc(PreciseSFunc &F, + const Word &u, const PreciseSFunc &init) const; + + RESULT forward(PreciseSFunc &F, const Word &u) const; + RESULT forwardprecalc(PreciseSFunc &F, + const Word &u, const PreciseSFunc &init) const; + + + // return the forward list vectors + RESULT logforward(list < PreciseSFunc > &F, const Word &u) const; + RESULT logforwardprecalc(list < PreciseSFunc > &F, + const Word &u, const PreciseSFunc &init) const; + RESULT logbackward(list < PreciseSFunc > &B, const Word &u) const; + RESULT logbackwardprecalc(list < PreciseSFunc > &B, // la liste des vecteurs + const Word &u, // le mot + const PreciseSFunc & term) const; // le vecteur terminal + + + // Apprentissage + RESULT BaumWelch(const Sample &S, + TransitionFunction &T, + SFunc &Iota, + SFunc &Tau, + int nb_tours, + bool verbose=false); + RESULT TransitionCount( const Sample &S, + TransitionFunction &T, + SFunc &Iota, + SFunc &Tau) const; + + RESULT TransitionCount( const Word &u, + TransitionFunction &T, + SFunc &Iota, + SFunc &Tau, + const int nb_apparitions) const; + + float count_nb_pass(const State x, const Sample &S) const; + +public: + RESULT renormalise(void); + RESULT erase_bad_states(void); +private: + float val_outstate(const State q) const; +}; +#endif diff --git a/spfa.cpp b/spfa.cpp new file mode 100644 index 0000000..c6833f7 --- /dev/null +++ b/spfa.cpp @@ -0,0 +1,1284 @@ +/*************************************************************************** + spfa.cpp + ------------------- + begin : Sun 7 Dec 2002 + copyright : (C) 2002 by Yann Esposito + email : esposito@cmi.univ-mrs.fr +***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +/* + Pour les notes, voir le fichier "spfa.h". + See "ffa.h" file to view notes. +*/ + +#include "spfa.H" +#include + +// Ajoute un Ètat +RESULT SPFA::addNewState (const float init, const float term) +{ + if (PFA_SAFE) + { + assert (init >= 0); + assert (init <= 1); + assert (term >= 0); + assert (term <= 1); + } + return MA::addNewState (init, term); + if (PFA_SAFE) + { + assert (isSPFA ()); + } +} + +// Fonction qui ajoute une transition +RESULT SPFA::addTransition (const Transition & t, const float val) +{ + return MA::addTransition (t, val); + if (PFA_SAFE) + assert (isSPFA ()); +} + +// Ajout d'une transition +RESULT SPFA::addTransition (const State qdep, const Lettre a, const State qarr, const float val) +{ + return MA::addTransition (qdep, a, qarr, val); + if (PFA_SAFE) + { + assert (isSPFA ()); + } +} + +// Donne un SPFA aleatoire +RESULT SPFA::becomeRandom (const int nb_etats, + const int nb_lettres, + const int num_graphe, + const float densite, + const float prob_init, + const float prob_term, + const float min_trans, const float max_trans) +{ + + // On gÈnËre un MA alÈatoire avec seulement des arÃtes positives + MA::becomeRandom (nb_etats, nb_lettres, + num_graphe, densite, + prob_init, prob_term, min_trans, max_trans); + + // On rend le MA en SPFA + return renormalise (); +} + +// Cree un MA aleatoire avec un nombre maximal d'aretes +RESULT SPFA::becomeRandomMax (const int nb_etats, const int nb_lettres, + const int num_graphe, const int nb_succ, + const int nb_init, const int nb_term, + const float min_trans, const float max_trans) +{ + MA::becomeRandomMax(nb_etats, nb_lettres, num_graphe, nb_succ, nb_init, nb_term,min_trans,max_trans); + return renormalise(); +} + + +RESULT SPFA::becomeRandomPrefix (const int nb_etats, + const int nb_lettres, + const int num_graphe, + const float densite, + const float prob_init, + const float prob_term, + const float min_trans, const float max_trans) +{ + + // On gÈnËre un MA alÈatoire avec seulement des arÃtes positives + MA::becomeRandomPrefix (nb_etats, nb_lettres, + num_graphe, densite, + prob_init, prob_term, min_trans, max_trans); + + // on rend un SPFA + return renormalise (); +} + + +RESULT SPFA::renormalise () +{ + if (!Q.empty()) + { + // --- On renormalise la fonction d'initialisation --- + SFunc::iterator s; + double sum, sum2; + // on gere le cas ou il n'y a pas d'etat initial + if (iota.empty ()) + { + iota[*(Q.begin ())] = 1; + } + else + { + // on calcule 1/somme des iota + sum = 0; + for (s = iota.begin (); s != iota.end (); ++s) + { + sum += s->second; + } + + // on renormalise tous les iota + sum2 = 0; + for (s = iota.begin (); s != iota.end (); s++) + { + s->second = s->second / sum; + sum2 += s->second; + } + // on repare encore un peu + iota.begin()->second += 1 - sum2; + } + + // Pour chaque etat on regarde la somme de ce qui sort + StateSet::const_iterator q; + Graph::iterator g; + LettreSFunc::iterator a; + for (q = Q.begin (); q != Q.end (); q++) + { // pour tous les Ètats + // on calcule ce qui sort de l'etat + sum = val_outstate(*q); + if (sum == 0) // si rien ne sort de l'etat, on met ‡ jour tau + { + tau[*q] = 1; + } + else + { + // on renormalise en prenant en compte les problËmes de virgule + g=phi.find(*q); + sum2 = 0; + if (g != phi.end ()) + { + for (a = g->second.begin (); a != g->second.end (); ++a) + { + for (s = a->second.begin (); s != a->second.end (); ++s) + { + s->second /= sum; + sum2 += s->second; + } + } + } + // si la somme ne fait pas encore 1 on + // met ‡ jour la valeur d'une arete ou de tau + if (sum2 != 1) + { + // si tau est non nul c'est lui que l'on modifie + if ((tau.find (*q) != tau.end ()) || (g == phi.end())) + { + tau[*q] = 1 - sum2; + } + else + { // sinon on repare un peu une transition + bool trouve = false; + for (a = g->second.begin (); + (a != g->second.end ()) && !trouve; + ++a) + { + s = a->second.begin (); + if (s != a->second.end ()) + { + trouve = true; + s->second += 1 - sum2; + } + } + } + } + } + } + + if (PFA_DEBUG) + { + if (!isSPFA ()) + { + cerr << "ERREUR de la fonction SPFA::renormalise()" << + endl; + } + } + return isSPFA (); + } + else + return false; +} +// le logarithme de la fonction phi Ètendue aux mots +double +SPFA::philog (const State q, const Word & u, const State s, + const Dictionnaire * dico) const +{ + Word::const_iterator a; + PreciseSFunc V; // Le vecteur contenant log(p(w)) + PreciseSFunc Vbis; + StateSet::const_iterator r; + PreciseSFunc::iterator si; + double tmp; + + if (dico == NULL) + { + V[q] = 0; + for (a = u.begin (); a != u.end (); a++) + { + + + Vbis.clear (); + for (r = Q.begin (); r != Q.end (); r++) + { + // Calcul du nouveau vecteur + tmp = 0; + for (si = V.begin (); si != V.end (); si++) + { + if (val_phi (si->first, *a, *r) != 0) + { + if (Vbis.find (*r) != + Vbis.end ()) + { + Vbis[*r] = + sumlog (Vbis[*r], si->second + log(val_phi(si->first,*a, *r))); + } + else + { + Vbis[*r] = si->second + log(val_phi(si->first,*a, *r)); + } + } + } + } + V = Vbis; + } + return V[s]; + } + else // les dictionnaires ne sont peut-etre pas Èquivalents + { + Word w; + Dictionnaire::const_iterator tl; + TrueLettre b; + + w.clear (); + for (a = u.begin (); a != u.end (); ++a) + { + tl = dico->find (*a); + if (tl == dico->end ()) + { + cerr << "Erreur !!! SPFA::philog, bad dictionnary !" << endl; + } + else + { + b = tl->second; + for (tl = alph.begin (); + (tl->second != b) + && (tl != alph.end ()); ++tl) + ; + if (tl == alph.end ()) + { + cerr << "Erreur 2 !!! SPFA::philog, bad dictionnary" << endl; + } + else + { + w += tl->first; + } + } + } + + V[q] = 0; + for (a = w.begin (); a != w.end (); ++a) + { + Vbis.clear (); + for (r = Q.begin (); r != Q.end (); ++r) + { + // Calcul du nouveau vecteur + tmp = 0; + for (si = V.begin (); si != V.end (); ++si) + { + if (val_phi (si->first, *a, *r) != 0) + { + if (Vbis. + find (*r) != Vbis.end ()) + { + Vbis[*r] =sumlog (Vbis[*r],si->second+log(val_phi(si-> first, *a,*r))); + } + else + { + Vbis[*r] =si->second +log (val_phi(si-> first,*a,*r)); + } + } + } + } + V = Vbis; + } + return V[s]; + } + +} + +// la proba conditionnÈe i.e. p(q|u) +double +SPFA::plog (const State q, const Word & u, const Dictionnaire * dico) const +{ + Word::const_iterator a; + PreciseSFunc V; // Le vecteur contenant log(p(w)) + PreciseSFunc Vbis; + SFunc::const_iterator e; + StateSet::const_iterator r; + PreciseSFunc::iterator s; + double res, tmp; + + for (e = iota.begin (); e != iota.end (); ++e) + V[e->first] = log (e->second); + + if ((dico == NULL) || (*dico == alph)) + { + for (a = u.begin (); a != u.end (); ++a) + { + Vbis.clear (); + for (r = Q.begin (); r != Q.end (); ++r) + { + // Calcul du nouveau vecteur + tmp = 0; + for (s = V.begin (); s != V.end (); ++s) + { + if (val_phi (s->first, *a, *r) != 0) + { + if (Vbis.find (*r) != + Vbis.end ()) + { + Vbis[*r] = sumlog(Vbis[*r], + s->second + log(val_phi(s->first,*a, *r))); + } + else + { + Vbis[*r] = + s->second + log(val_phi(s->first,*a, *r)); + } + } + } + } + V = Vbis; + } + + // res=exp(V[q] - sum_r V[r]) + if (V.find (q) != V.end ()) + { + res = log ((double) 0); + for (s = V.begin (); s != V.end (); ++s) + res = sumlog (res, s->second); + res = V[q] - res; + } + else + { + res = log ((double) 0); + } + + return res; + } + else // dico != NULL + { + Word w; + Dictionnaire::const_iterator tl; + TrueLettre b; + + w.clear (); + for (a = u.begin (); a != u.end (); ++a) + { + tl = dico->find (*a); + if (tl == dico->end ()) + { + cerr << "Erreur !!! SPFA::philog, bad dictionnary !" << endl; + } + else + { + b = tl->second; + tl = alph.begin() ; + while ((tl != alph.end()) && (tl->second != b)) + ++tl; + if (tl == alph.end ()) + { + cerr << "Erreur 2 !!! SPFA::philog, bad dictionnary" << endl; + } + else + { + w += tl->first; + } + } + } + + + for (a = w.begin (); a != w.end (); ++a) + { + Vbis.clear (); + for (r = Q.begin (); r != Q.end (); ++r) + { + // Calcul du nouveau vecteur + tmp = 0; + for (s = V.begin (); s != V.end (); ++s) + { + if (val_phi (s->first, *a, *r) != 0) + { + if (Vbis.find (*r) != Vbis.end ()) + { + Vbis[*r] = + sumlog(Vbis[*r], + s->second + log(val_phi(s->first,*a, *r))); + } + else + { + Vbis[*r] = s->second + log(val_phi(s->first,*a, *r)); + } + } + } + } + V = Vbis; + } + + // res=exp(V[q] - sum_r V[r]) + if (V.find (q) != V.end ()) + { + res = log ((double) 0); + for (s = V.begin (); s != V.end (); ++s) + res = sumlog (res, s->second); + res = V[q] - res; + } + else + { + res = log ((double) 0); + } + + return res; + } +} + +// la fonction p directe +double SPFA::p_directe (const Word & u, const Dictionnaire * dico) const +{ + PreciseSFunc F; + PreciseSFunc::const_iterator x; + SFunc::const_iterator t; + double res; + if ((dico == NULL) || (*dico == alph)) { + forward(F,u); + res = 0.0; + for (x=F.begin() ; x!=F.end() ; ++x) { + t = tau.find(x->first); + if (t != tau.end()) { + res += x->second * double(t->second); + } + } + return res; + } + else { + // le dictionnaire n'est pas identique, on doit traduire le mot + Word v; + Word::const_iterator a; + Dictionnaire::const_iterator tl; + Dictionnaire::const_iterator tl2; + map traducteur; + for (tl = dico->begin() ; tl != dico->end() ; ++tl) + { + tl2 = alph.begin(); + while ((tl2 != alph.end()) && (tl2->second != tl->second)) + ++tl2; + if (tl2 == alph.end()) + { + cerr << "Erreur !!! SPFA::philog, bad dictionnary ! lettre " << tl->second << endl; + } + else + { + traducteur[tl->first] = tl2->first; + } + } + for (a=u.begin() ; a != u.end() ; ++a) { + v += traducteur[*a]; + } + + forward(F,v); + res = 0.0; + for (x=F.begin() ; x!=F.end() ; ++x) { + t = tau.find(x->first); + if (t != tau.end()) { + cout << "^^" << x->second << " * " << t->second << endl; + res += x->second * double(t->second); + } + } + return res; + } +} + + +// la fonction p directe +double SPFA::p_bar_directe (const Word & u, const Dictionnaire * dico) const +{ + PreciseSFunc F; + PreciseSFunc::const_iterator x; + SFunc::const_iterator t; + double res; + if ((dico == NULL) || (*dico == alph)) { + forward(F,u); + res = 0.0; + for (x=F.begin() ; x!=F.end() ; ++x) { + res += x->second; + } + return res; + } + else { + // le dictionnaire n'est pas identique, on doit traduire le mot + Word v; + Word::const_iterator a; + Dictionnaire::const_iterator tl; + Dictionnaire::const_iterator tl2; + map traducteur; + for (tl = dico->begin() ; tl != dico->end() ; ++tl) + { + tl2 = alph.begin(); + while ((tl2 != alph.end()) && (tl2->second != tl->second)) + ++tl2; + if (tl2 == alph.end()) + { + cerr << "Erreur !!! SPFA::philog, bad dictionnary ! lettre " << tl->second << endl; + } + else + { + traducteur[tl->first] = tl2->first; + } + } + for (a=u.begin() ; a != u.end() ; ++a) { + v += traducteur[*a]; + } + + forward(F,v); + res = 0.0; + for (x=F.begin() ; x!=F.end() ; ++x) { + res += x->second; + } + return res; + } +} + + +// le logarithme de la fonction p +double SPFA::plog (const Word & u, const Dictionnaire * dico) const +{ + PreciseSFunc F; + PreciseSFunc::const_iterator x; + SFunc::const_iterator t; + double res; + double tmp; + if ((dico == NULL) || (*dico == alph)) { + logforward(F,u); + res = log(0.0); + for (x=F.begin() ; x!=F.end() ; ++x) { + t = tau.find(x->first); + if (t != tau.end()) { + tmp=x->second+log(double(t->second)); + if (!isinf(tmp)) { + res = sumlog(res, tmp); + } + } + } + return res; + } + else { + // le dictionnaire n'est pas identique, on doit traduire le mot + Word v; + Word::const_iterator a; + Dictionnaire::const_iterator tl; + Dictionnaire::const_iterator tl2; + map traducteur; + for (tl = dico->begin() ; tl != dico->end() ; ++tl) + { + tl2 = alph.begin(); + while ((tl2 != alph.end()) && (tl2->second != tl->second)) + ++tl2; + if (tl2 == alph.end()) + { + cerr << "Erreur !!! SPFA::philog, bad dictionnary ! lettre " << tl->second << endl; + } + else + { + traducteur[tl->first] = tl2->first; + } + } + for (a=u.begin() ; a != u.end() ; ++a) { + v += traducteur[*a]; + } + + logforward(F,v); + res = log(0.0); + for (x=F.begin() ; x!=F.end() ; ++x) { + t = tau.find(x->first); + if (t != tau.end()) { + res = sumlog(res,x->second + log(double(t->second))); + } + } + return res; + } +} + +// ---------------- calcul des probas + +double SPFA::p_bar(const Word &u, const Dictionnaire * dico) const { + return exp(plog_bar(u)); +} + +double SPFA::plog_bar(const Word &u, const Dictionnaire * dico) const { + // PreciseSFunc F; + // PreciseSFunc::const_iterator f; + // double res; + // logforward(F,u); + // res = log(0.0); + // for (f=F.begin() ; f != F.end() ; f++) { + // res = sumlog(res, f->second); + // } + // return res; + // ------------- + + + PreciseSFunc F; + PreciseSFunc::const_iterator x; + SFunc::const_iterator t; + double res; + if ((dico == NULL) || (*dico == alph)) { + logforward(F,u); + res = log(0.0); + for (x=F.begin() ; x!=F.end() ; ++x) { + if (!isinf(x->second)) { + res = sumlog(res,x->second); + } + } + return res; + } + else { + // le dictionnaire n'est pas identique, on doit traduire le mot + Word v; + Word::const_iterator a; + Dictionnaire::const_iterator tl; + Dictionnaire::const_iterator tl2; + map traducteur; + for (tl = dico->begin() ; tl != dico->end() ; ++tl) + { + tl2 = alph.begin(); + while ((tl2 != alph.end()) && (tl2->second != tl->second)) + ++tl2; + if (tl2 == alph.end()) + { + cerr << "Erreur !!! SPFA::philog, bad dictionnary ! lettre " << tl->second << endl; + } + else + { + traducteur[tl->first] = tl2->first; + } + } + for (a=u.begin() ; a != u.end() ; ++a) { + v += traducteur[*a]; + } + + logforward(F,v); + res = log(0.0); + for (x=F.begin() ; x!=F.end() ; ++x) { + if (!isinf(x->second)) { + res = sumlog(res,x->second); + } + } + return res; + } + +} + +RESULT SPFA::forward(PreciseSFunc &F, const Word &u) const { + PreciseSFunc init; + SFunc::const_iterator q; + for (q=iota.begin() ; q!= iota.end() ; q++) + { + init[q->first] = q->second; + } + return forwardprecalc(F,u,init); +} + +RESULT SPFA::logforward( + PreciseSFunc &F, + const Word &u) const +{ + PreciseSFunc init; + SFunc::const_iterator q; + for (q=iota.begin() ; q!=iota.end() ; ++q) + { + init[q->first] = q->second; + } + return logforwardprecalc(F,u,init); +} + + +RESULT SPFA::forwardprecalc( + PreciseSFunc &F, + const Word &u, + const PreciseSFunc &init_vector) const +{ + F.clear(); + + PreciseSFunc V; + PreciseSFunc::const_iterator e; + Word::const_iterator a; + PreciseSFunc Vbis; + PreciseSFunc::iterator s; + Graph::const_iterator q; + LettreSFunc::const_iterator b; + SFunc::const_iterator r; + + + for (e = init_vector.begin (); e != init_vector.end (); ++e) { + if (e->second != 0) { + V[e->first] = e->second; + } + } + + for (a = u.begin (); a != u.end (); ++a) + { + Vbis.clear (); + for (s=V.begin() ; s != V.end() ; ++s) { + q=phi.find(s->first); + if (q != phi.end() ) { + b=q->second.find(*a); + if (b != q->second.end()) { + for (r=b->second.begin() ; r != b->second.end() ; ++r) { + if (Vbis.find(r->first) != Vbis.end()) { + Vbis[r->first] = Vbis[r->first] + r->second*s->second; + } + else { + Vbis[r->first] = r->second*s->second; + } + } + } + } + } + V = Vbis; + } + F=V; + return VAL(0); +} + +RESULT SPFA::logforwardprecalc( + PreciseSFunc &F, + const Word &u, + const PreciseSFunc &init_vector) const +{ + F.clear(); + + PreciseSFunc V; + PreciseSFunc::const_iterator e; + + for (e = init_vector.begin (); e != init_vector.end (); ++e) { + if (e->second != 0) { + V[e->first] = log (e->second); + } + } + + Word::const_iterator a; + PreciseSFunc Vbis; + PreciseSFunc::iterator s; + + Graph::const_iterator q; + LettreSFunc::const_iterator b; + SFunc::const_iterator r; + + for (a = u.begin (); a != u.end (); ++a) + { + Vbis.clear (); + for (s=V.begin() ; s != V.end() ; ++s) { + q=phi.find(s->first); + if (q != phi.end() ) { + b=q->second.find(*a); + if (b != q->second.end()) { + for (r=b->second.begin() ; r != b->second.end() ; ++r) { + if (Vbis.find(r->first) != Vbis.end()) { + Vbis[r->first] = sumlog(Vbis[r->first], + log(r->second) + s->second); + } + else { + Vbis[r->first] = log(r->second) + s->second; + } + } + } + } + } + V = Vbis; + + //~ for (e=Vbis.begin() ; e!=Vbis.end() ; ++e) { + //~ if (!isinf(e->second)) { + //~ V[e->first]=e->second; + //~ } + //~ } + } + F=V; + return VAL(0); +} + + +// ---------------- LA PARTIE BAULM WELCH + +RESULT SPFA::logforward( + list < PreciseSFunc > &F, + const Word &u) const +{ + PreciseSFunc init; + SFunc::const_iterator q; + for (q=iota.begin() ; q!=iota.end() ; ++q) + { + init[q->first] = q->second; + } + return logforwardprecalc(F,u,init); +} + +RESULT SPFA::logforwardprecalc( + list < PreciseSFunc > &F, + const Word &u, + const PreciseSFunc &init_vector) const +{ + F.clear(); + + PreciseSFunc V; + PreciseSFunc::const_iterator e; + for (e = init_vector.begin (); e != init_vector.end (); ++e) { + if (e->second != 0) { + V[e->first] = log (e->second); + } + } + F.push_back(V); + + Word::const_iterator a; + PreciseSFunc Vbis; + PreciseSFunc::iterator s; + + Graph::const_iterator q; + LettreSFunc::const_iterator b; + SFunc::const_iterator r; + + for (a = u.begin (); a != u.end (); ++a) + { + Vbis.clear (); + for (s=V.begin() ; s != V.end() ; ++s) { + q=phi.find(s->first); + if (q != phi.end() ) { + b=q->second.find(*a); + if (b != q->second.end()) { + for (r=b->second.begin() ; r != b->second.end() ; ++r) { + if (Vbis.find(r->first) != Vbis.end()) { + Vbis[r->first] = sumlog(Vbis[r->first], + log(r->second) + s->second); + } + else { + Vbis[r->first] = log(r->second) + s->second; + } + } + } + } + } + V = Vbis; + //~ for (e=Vbis.begin() ; e!=Vbis.end() ; ++e) { + //~ if (!isinf(e->second)) { + //~ V[e->first]=e->second; + //~ } + //~ } + F.push_back(V); + } + return VAL(0); +} + +RESULT SPFA::logbackward( + list < PreciseSFunc > &B, + const Word &u) const +{ + // copie de tau dans term + PreciseSFunc term; + SFunc::const_iterator q; + for (q=tau.begin() ; q != tau.end() ; ++q) + { + term[q->first]=q->second; + } + return logbackwardprecalc(B,u,term); +} + +RESULT SPFA::logbackwardprecalc( + list < PreciseSFunc > &B, + const Word &u, + const PreciseSFunc &term) const +{ + + B.clear(); + + PreciseSFunc::const_iterator e; + PreciseSFunc V; + for (e = term.begin (); e != term.end (); ++e) { + if (e->second != 0) { + V[e->first] = log (e->second); + } + } + + B.push_front(V); + + Word::const_reverse_iterator a; + Graph::const_iterator q; + LettreSFunc::const_iterator b; + SFunc::const_iterator s; + PreciseSFunc Vbis; + + + for (a = u.rbegin (); a != u.rend (); ++a) + { + Vbis.clear (); + for (q=phi.begin() ; q != phi.end() ; ++q) { + b=q->second.find(*a); + if (b != q->second.end()) { + for (s=b->second.begin() ; s != b->second.end() ; ++s) { + if (V.find(s->first) != V.end()) { + if (Vbis.find(q->first) == Vbis.end()) { + Vbis[q->first] = log(s->second) + V[s->first]; + } + else { + Vbis[q->first] = sumlog( Vbis[q->first], + log(s->second) + V[s->first]); + } + } + } + } + } + + V=Vbis; + B.push_front(V); + } + return VAL(0); +} + +// Compte le nombre de fois que l'on passe par chaque transition de +// facon pondÈree. +RESULT SPFA::TransitionCount(const Sample &S, + TransitionFunction &T, + SFunc &Iota, + SFunc &Tau) const +{ + TransitionFunction::iterator t; + SFunc::iterator s; + Sample::const_iterator u; + // on initialise le compte d'utilisation des transitions + for (t=T.begin() ; t != T.end() ; ++t) + { + t->second = 0; + } + for (s=Iota.begin() ; s != Iota.end() ; ++s) { + s->second = 0; + } + for (s=Tau.begin() ; s != Tau.end() ; ++s) { + s->second=0; + } + + for (u=S.begin() ; u != S.end() ; ++u) + { + TransitionCount(u->first, T, Iota, Tau, u->second); + //~ // ---- + //~ cout << "\t: " << affiche(u->first) << "," << u->second << " : "; + //~ for (t=T.begin() ; t != T.end() ; ++t) { + //~ cout << "("; + //~ cout << t->first.qdep << ","; + //~ cout << t->first.a << ","; + //~ cout << t->first.qarr << ")="; + //~ cout << t->second << ","; + //~ } + //~ for (s=Iota.begin() ; s != Iota.end() ; ++s) { + //~ cout << " i(" << s->first << ")=" << s->second; + //~ } + //~ for (s=Tau.begin() ; s!=Tau.end() ; ++s) { + //~ cout << " t(" << s->first << ")=" << s->second; + //~ } + //~ cout << endl; + //~ // ---- + } + return VAL(0); +} + + +// Compte le nombre de fois que l'on passe par chaque transition de +// facon pondÈree. +RESULT SPFA::TransitionCount(const Word &u, + TransitionFunction &T, + SFunc &Iota, + SFunc &Tau, + const int nb_occurences) const +{ + + // Algorithme renvoie sum_{t} \eta_t(i, a) + // \eta_t(i,a) = \alph_t(i) x \phi(i, w_t=a ,j) x \beta_t(j) / P(w) + // on calcule alpha et beta pour tout i + + list < PreciseSFunc > F; // forward + list < PreciseSFunc > B; // backward + list < PreciseSFunc >::const_iterator f; + list < PreciseSFunc >::const_iterator b; + logforward(F,u); + logbackward(B,u); + + + Word::const_iterator a; + PreciseSFunc::const_iterator x; + PreciseSFunc::const_iterator y; + Transition t; + double plogu=log(0.);// =plog(u); + double tmp; + + //~ // AFFICHAGE DE F et B + //~ cout << "Forward" << endl; + //~ for (f=F.begin() ; f != F.end() ; ++f) { + //~ for (x = f->begin() ; x != f->end() ; ++x) { + //~ cout << "(" << x->first << "," << x->second << ") "; + //~ } + //~ cout << endl; + //~ } + + //~ cout << "Backward" << endl; + //~ for (b=B.begin() ; b != B.end() ; ++b) { + //~ for (y = b->begin() ; y!=b->end() ; ++y) { + //~ cout << "(" << y->first << "," << y->second << ") "; + //~ } + //~ cout << endl; + //~ } + + f=F.begin(); + b=B.begin(); + for (x=f->begin() ; x != f->end() ; ++x) { + y=b->find(x->first); + plogu = sumlog(plogu, x->second + y->second); + } + + //~ cout << "plogu = " << plogu << endl; + //~ cout << "plogu calcule = " << plog(u) << endl; + + + f=F.begin(); + b=B.begin(); + for (x=f->begin() ; x != f->end() ; ++x) { + y=b->find(x->first); + if ((Iota.find(x->first) != Iota.end()) && (y != b->end())) { + tmp = exp(x->second + y->second + log(float(nb_occurences)) - plogu); + if (! isnan(tmp)) { + Iota[x->first] += tmp; + } + else { + cout << "IOTA nan : " << x->first; + cout << "," << y->first; + cout << ":" << x->second; + cout << " " << y->second; + cout << " " << log(float(nb_occurences)); + cout << " " << plogu; + cout << endl; + } + } + } + + f=--F.end(); + b=--B.end(); + for (x=f->begin() ; x != f->end() ; ++x) { + y = b->find(x->first); + if ((Tau.find(x->first) != Tau.end()) && (y != b->end())) { + tmp = exp(x->second + y->second + log(float(nb_occurences)) - plogu); + if (!isnan(tmp)) { + Tau[x->first] += tmp; + } + else { + cout << "TAU nan : " << x->first; + cout << "," << y->first; + cout << ":" << x->second; + cout << " " << y->second; + cout << " " << log(float(nb_occurences)); + cout << " " << plogu; + cout << endl; + } + } + } + + for (a = u.begin(), + f=F.begin() , + b=B.begin() , + b++ ; // on avance de ce qu'il faut + + a != u.end() ; + + ++a, ++f, ++b) + { + for (x=f->begin() ; x != f->end() ; ++x) + { + for (y=b->begin() ; y != b->end() ; ++y) + { + t.qdep = x->first; + t.a = *a; + t.qarr = y->first; + if (T.find(t) != T.end()) + { + if (val_phi(x->first, *a, y->first) != 0) { + tmp= exp(x->second + + y->second + + log(val_phi(x->first, *a, y->first)) - + plogu + log(float(nb_occurences))); + + if (!isnan(tmp)) { + T[t] +=tmp; + } + else { + cout << "PHI nan : " << x->first; + cout << "," << *a; + cout << "," << y->first; + cout << ":" << x->second; + cout << " " << y->second; + cout << " " << log(val_phi(x->first, *a, y->first)); + cout << " " << plogu; + cout << " " << log(float(nb_occurences)); + cout << endl; + } + } + } + } + } + } + return VAL(0); +} + +RESULT SPFA::BaumWelch(const Sample &S, + TransitionFunction &T, + SFunc &Iota, + SFunc &Tau, + int nb_tours, + bool verbose) +{ + + if (S.isprefixiel()) { + cerr << "BaumWelch():: Sample prefixiel !" << endl; + return ERR(1); + } + + // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + // Il faut Iota = tous les Ètats initiaux ou rien + // si (q,a,r) est dans T ou q dans Tau, il faut tous les (q,x,s) + tau(q). + // Sinon la renormalisation devient fausse + Sample::const_iterator u; + TransitionFunction::iterator t; + + // on initialise la probabilite de sortir de chaque etats + SFunc count_out; + Graph::const_iterator q; + LettreSFunc::const_iterator b; + SFunc::iterator s; +// int i=0; + double sum; + + while (nb_tours-- != 0) + { + //~ if (verbose) + //~ { + //~ cout << "[BM " << nb_tours << "] "; + //~ cout.flush(); + //~ } + + TransitionCount(S,T,Iota,Tau); + + for (t=T.begin() ; t != T.end() ; ++t) { + count_out[t->first.qdep] += t->second; + } + for (s=Tau.begin() ; s!=Tau.end() ; ++s) { + count_out[s->first] += s->second; + } + sum=0; + for (s=Iota.begin() ; s!= Iota.end() ; ++s) { + sum +=s->second; + } + + for (t=T.begin() ; t != T.end() ; ++t) + { + if (t->second != 0) { + SPFA::addTransition(t->first, t->second / count_out[t->first.qdep]); + } + else { + SPFA::addTransition(t->first, 0); + } + } + for (s=Tau.begin() ; s != Tau.end() ; ++s) { + if (s->second != 0) { + tau[s->first]= s->second / count_out[s->first]; + } + else { + tau[s->first]=0; + } + } + for (s=Iota.begin() ; s != Iota.end() ; ++s) { + iota[s->first] = s->second / sum; + } + + erase_transitions(); + + //~ if (verbose) + //~ { + //~ cout << endl; + //~ for (t=T.begin() ; t != T.end() ; ++t) + //~ { + //~ cout << "("; + //~ cout << t->first.qdep; + //~ cout << ","; + //~ cout << t->first.a; + //~ cout << ","; + //~ cout << t->first.qarr; + //~ cout << ")="; + //~ cout << t->second / count_out[t->first.qdep]; + //~ if (++i%5 == 0) cout << "\n"; + //~ else cout << " "; + //~ } + //~ for (s = Tau.begin() ; s != Tau.end() ; ++s) { + //~ cout << "t(" << s->first << ")=" << s->second / count_out[s->first]; + //~ if (++i%5 == 0) cout << "\n"; + //~ else cout << " "; + //~ } + //~ for (s = Iota.begin() ; s != Iota.end() ; ++s) { + //~ cout << "i(" << s->first << ")=" << s->second / sum; + //~ if (++i%5 == 0) cout << "\n"; + //~ else cout << " "; + //~ } + //~ cout << endl; + //~ } + + count_out.clear(); + } + + return VAL(0); +} + +// fonction qui calcule les probas qui sortes d'un Ètat +// transitions + arret +float SPFA::val_outstate(const State q) const { + float sum; + Graph::const_iterator r; + LettreSFunc::const_iterator a; + SFunc::const_iterator s; + + sum=val_tau(q); + r=phi.find(q); + if (r != phi.end() ) { + for (a=r->second.begin() ; a != r->second.end() ; ++a) { + for (s=a->second.begin() ; s != a->second.end() ; ++s) { + sum += s->second; + } + } + } + return sum; +} + +RESULT SPFA::erase_bad_states(void) { + + StateSet::iterator q; + LettreSFunc::iterator a; + SFunc::iterator s; + for (q=Q.begin() ; q != Q.end() ; ++q) { + if (val_outstate(*q) == 0) { + erase(*q); + } + } + return VAL(0); +} diff --git a/test.H b/test.H new file mode 100644 index 0000000..a9d8342 --- /dev/null +++ b/test.H @@ -0,0 +1,13 @@ +/* + * test.h + * dees + * + * Created by Yann Esposito on 19/12/05. + * Copyright 2005 Yann Esposito. All rights reserved. + * + */ + +// --- Une fonction de test (ne sert qu'au débogage) --- +void test_du_simplexe (void); +void test_PSe(void); +void test(void); diff --git a/test.cpp b/test.cpp new file mode 100644 index 0000000..f593bfb --- /dev/null +++ b/test.cpp @@ -0,0 +1,92 @@ +/* + * test.cpp + * dees + * + * Created by Yann Esposito on 19/12/05. + * Copyright 2005 __MyCompanyName__. All rights reserved. + * + */ + +#include "main.H" +#include "test.H" +#include "include/lp_lib.h" + +void test_PSe(void) { + MA A; + SFunc PSe; + SFunc::const_iterator q; + int res; + + // A.becomeRandom(2,2); + // A.save("test/testPSe.ma"); + A.load("test/testPSe.ma"); + + res = A.val_PSe(PSe); + cout << "res = " << res << endl; + + for (q=PSe.begin() ; q != PSe.end() ; q++) { + cout << "P_" << q->first << "(\Se) = " << q-> second << endl; + } +} + +void test_genere_mot_MA(void) { + MA A; + Word w; + int i; + A.load("test/testGenMot.ma"); + + for (i=0;i<1;i++){ + cout << "i=" << i << " : "; + A.genere_mot(w); + cout << A.affiche(w); + cout << endl; + } +} + + +void test_simplex() { + Simplex simplex; + + int i,j; + int nbinc, nbcont; + double input; + + cout << "Entrez le nombre d'inconnues : "; + cin >> nbinc; + simplex.set_number_of_unknown_to(nbinc); + cout << "Entrez le nombres de contraintes : " ; + cin >> nbcont; + cout << "Entrez les contraintes (pour 3*X1 + 2*X2 = 4 écrire 3 2 4) : " << endl; + + for (i = 1 ; i<= nbcont ; i++) { + for (j=1 ; j<= nbinc ; j++) { + cin >> input; + simplex.setparam(j,input); + } + cin >> input; + simplex.setval(input); + simplex.add_equality_constraint(); + } + + simplex.set_mode(realNotBounded); + simplex.set_minimize_epsilon_mode(-1); + + map sol; + float epsilon; + if (simplex.has_solution(sol,epsilon)) { + cout << "Solution : " << endl; + cout << "epsilon = " << epsilon << endl; + for (i = 1 ; i<= nbinc ; i++) { + cout << "X" << i << "=" << sol[i] << " ; "; + } + cout << endl; + } + else { + cout << "Pas de solution..." << endl; + } + +} + +void test(void) { + test_simplex(); +} diff --git a/toto b/toto new file mode 100644 index 0000000..e69de29 diff --git a/ySimplex.cpp b/ySimplex.cpp new file mode 100644 index 0000000..e3b2adb --- /dev/null +++ b/ySimplex.cpp @@ -0,0 +1,365 @@ +// Algorithme dual du simplexe (méthode de Lemke) (fonction simplexe_dual). + +// a : le tableau des coefficients du problème ; +// sol : un tableau renvoyant la solution optimale ; +// ineq1 : le nombre des inéquations en <= ; +// ineq2 : le nombre des inéquations en >= ; +// eq : le nombre des équations ; +// n : le nombre de variables. + +// Elle calcule dans le tableau sol une solution optimale du programme linéaire +// (l'opposé de la valeur correspondante de la fonction économique est calculé dans a[0][0]). + +// Les données doivent être fournies dans le tableau a de la façon suivante: + +// * ligne 0 de a : la fonction économique +// L'élément 0 est égal à 0, les éléments 1 à n aux coefficients des variables dans la fonction + +// * lignes 1 à ineq1 de a : les inéquations en <= +// L'élément 0 est égal au second membre, +// les éléments 1 à n aux coefficients des variables dans l'inéquation + +// * lignes ineq1+1 à ineq1+ineq2 de a : les inéquations en >= +// L'élément 0 est égal au second membre, +// les éléments 1 à n aux coefficients des variables dans l'inéquation + +// * lignes ineq1+ineq2+1 à ineq1+ineq2+eq de a : les équations +// L'élément 0 est égal au second membre, +// les éléments 1 à n aux coefficients des variables dans l'équation + + +#include "simplex.H" + +int Simplex::ads_sortant(int m,int n,int phase) +{ + int i,j,k,l; + double d,s,min; + l=0; + min=0.0; + k=0; + if(phase==1) + { + for(j=1;j<=n;j++) + { + if(hb[j]==n+m) + k=j; + } + } + if((phase==2)||(k!=0)) + { + for(i=1;i<=m;i++) + { + d=a[i][k]; + s=0.0; + if(d<0) + { + for (it=a[i].begin() ; it != a[i].end() ; it++) + s+=fabs(it->second); + d/=s; + if(dsecond = -(it->second); + for(i=1;i<=ineq1+ineq2;i++) + db[i]=n+i; + for(i=ineq1+ineq2+1;i<=m;i++) + db[i]=0; + for(j=1;j<=n;j++) + hb[j]=j; + if(eq!=0) + { + for(i=ineq1+ineq2+1;i<=m;i++) + { + l=i; + k=0; + for(j=1;j<=n;j++) + if(a[i][j]!=0) + k=j; + if(k==0) + { + if(a[i][0]!=0) + return(2); + } + else + { + pivotage(m,n,l,k); + hb[k]=hb[n]; + for(j=0;j<=m;j++) + a[j][k]=a[j][n]; + n-=1; + } + } + } + m1=m; + phase=2; + k=0; + max=0; + for(j=1;j<=n;j++) + if(a[0][j]>max) + { + max=a[0][j]; + k=j; + } + if(k!=0) + phase=1; + l=1; + if(phase==1) + { + m1=m+1; + for(j=1;j<=n;j++) + if(a[0][j]>0) + a[m1][j]=1; + else + a[m1][j]=0; + a[m1][0]=0; + db[m1]=n+m+1; + pivotage(m1,n,m1,k); + } + while(phase<=2) + { + do + { + l=ads_sortant(m1,n,phase); + if(l!=0) + { + k=ads_entrant(n,l); + if(k==0) + { + return(1); + } + pivotage(m1,n,l,k); + } + } + while(l!=0); + if(phase==1) + { + k=0; + for(j=1;j<=n;j++) + if(hb[j]==n+1+m) + k=j; + if(k!=0) + { + if(fabs(a[0][k])>1e-15) + return(2); + else + { + for(i=1;i<=m1;i++) + if(a[i][k]!=0) + l=i; + pivotage(m1,n,l,k); + } + } + } + if(phase==1) + { + for(i=1;i<=m1;i++) + if(db[i]==n+m1) + l=i; + db[l]=db[m1]; + for(j=0;j<=n;j++) + a[l][j]=a[m1][j]; + } + phase+=1; + m1-=1; + } + for(i=1;i<=m+n;i++) + sol[i]=0; + for(i=1;i<=m;i++) + sol[db[i]]=a[i][0]; + return (0); + } + catch (int erreur) + { + if (PFA_VERBOSE) + { + cerr << "ERREUR : Simplex::simplexe_dual" << endl; + switch (erreur) + { + default : + cerr << "Erreur n°" << erreur << endl; + } + } + return erreur; + } +} + +int Simplex::affiche(int ineq1, int ineq2, int nbeq, int nbvar) { + int i, j; + + cout << "--------------------------------" << endl; + cout << "Affichage du systme :" << endl; + cout << "--------------------------------" << endl; + char lettre = 'X'; + cout << " minimize : "; + for (i=1 ; i<=nbvar ; i++) { + cout << a[0][i] << lettre++ << " "; + } + cout << "::" << endl; + for (i=1 ; i<=ineq1 ; i++){ + lettre = 'X'; + for (j=1 ; j<=nbvar ; j++) { + if (a[i][j]>0) + cout << "+"; + cout << a[i][j] << lettre++ << " "; + } + cout << "<=" << a[i][0] << endl; + } + for (i=ineq1 + 1; i<= ineq1 + ineq2 ; i++) { + lettre = 'X'; + for (j=1 ; j<=nbvar ; j++) { + if (a[i][j]>0) + cout << "+"; + cout << a[i][j] << lettre++ << " "; + } + cout << ">=" << a[i][0] << endl; + } + for (i=ineq1 + ineq2 + 1 ; i<=ineq1 + ineq2 + nbeq ; i++) { + lettre = 'X'; + for (j=1 ; j<=nbvar ; j++) { + if (a[i][j]>0) + cout << "+"; + cout << a[i][j] << lettre++ << " "; + } + cout << "= " << a[i][0] << endl; + } + cout << "--------------------------------" << endl; + +} + +int Simplex::solve(int ineq1, int ineq2, int eq, int n, bool debug) { + try { + const int ntmp = n; + const int BORNEMAX = 1024; + int i,j,k; + int m=ineq1+ineq2+eq; + int res ; + + // MODIFICATION POUR GERER DES VARIABLES NEGATIVES + for (i=0 ; i <= m ; i++) { + for (j=1 ; j<=n ; j++) { + a[i][j+n] = -a[i][j]; + // cout << "a[" << i <<"][" << j << "]=" << a[i][j]; + // cout << "a[" << i << "][" << j+n << "]=" << a[i][j+n]; + } + // cout << endl; + } + n *= 2; + // FIN DE LA MODIFICATION + + // MODIFICATION POUR EVITER UN BUG DE PRECISION ; on borne + // toutes les variables + k = ineq1 + ineq2 + 1; + for (i=0 ; i

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