source: branches/dev-5819/Compiler/OptimicaFrontEnd/src/jastadd/OptimicaFlatAPI.jrag @ 13800

Last change on this file since 13800 was 13800, checked in by randersson, 7 weeks ago

#5819 Merged trunk into branch

File size: 33.4 KB
Line 
1/*
2    Copyright (C) 2009 Modelon AB
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, version 3 of the License.
7
8    This program is distributed in the hope that it will be useful,
9    but WITHOUT ANY WARRANTY; without even the implied warranty of
10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11    GNU General Public License for more details.
12
13    You should have received a copy of the GNU General Public License
14    along with this program.  If not, see <http://www.gnu.org/licenses/>.
15*/
16
17import java.util.LinkedHashSet;
18import java.util.Set;
19
20aspect OptimicaFlatAPI {
21       
22        public static final String FAttribute.FREE = "free";
23        public static final String FAttribute.INITIAL_GUESS = "initialGuess";
24       
25        // === free ===
26        /**
27         * Check if the free attribute is set for a variable.
28         */
29        syn boolean FVariable.freeAttributeSet()    = attributeSet(FAttribute.FREE);
30               
31        /**
32         * Get the free attribute expression.
33         *
34         * @return Attribute expression or null if not set.
35         */
36        syn FExp    FVariable.freeAttributeExp()    = attributeExp(FAttribute.FREE);
37
38        /**
39         * Get the free attribute CValue.
40         */
41        syn CValue  FVariable.freeAttributeCValue() = attributeCValueBoolean(FAttribute.FREE, false);
42    syn CValue  InstAssignable.freeAttributeCValue() {
43        CValue val = attributeCValueSet(defaultVariableEvaluator(), FAttribute.FREE);
44        if (val != null && !val.isUnknown()) {
45            return val;
46        }
47        return CValueBoolean.FALSE;
48    }
49               
50        /**
51         * Get the free attribute value.
52         *
53         * For an array, this is true if it is true for any cell in the array.
54         */
55        syn boolean FVariable.freeAttribute()       = freeAttributeCValue().reduceBooleanOr(); 
56    syn boolean InstAssignable.freeAttribute()  = freeAttributeCValue().reduceBooleanOr();
57        // === initialGuess ===
58        /**
59         * Check if the initialGuess attribute is set for a variable.
60         */
61        syn boolean FVariable.initialGuessAttributeSet()     = attributeSet(FAttribute.INITIAL_GUESS);
62
63        /**
64         * Get the initialGuess attribute expression.
65         */
66        syn FExp    FVariable.initialGuessAttributeExp()     = attributeExp(FAttribute.INITIAL_GUESS);
67       
68        /**
69         * Get the initialGuess attribute CValue.
70         */
71        syn CValue FVariable.initialGuessAttributeCValue()   = CValue.UNKNOWN;
72        eq FRealVariable.initialGuessAttributeCValue()       = attributeCValueReal(FAttribute.INITIAL_GUESS, 0.0);
73        eq FDerivativeVariable.initialGuessAttributeCValue() = CValueReal.valueOf(0.0);
74        eq FIntegerVariable.initialGuessAttributeCValue()    = attributeCValueInteger(FAttribute.INITIAL_GUESS, 0);
75        eq FBooleanVariable.initialGuessAttributeCValue()    = attributeCValueBoolean(FAttribute.INITIAL_GUESS, false);
76        eq FStringVariable.initialGuessAttributeCValue()     = attributeCValueString(FAttribute.INITIAL_GUESS);
77
78        /**
79         * Get the initialGuess attribute value.
80         */
81        syn double  FRealVariable.initialGuessAttribute()    = initialGuessAttributeCValue().realValue();
82        /**
83         * Get the initialGuess attribute value.
84         */
85        syn int     FIntegerVariable.initialGuessAttribute() = initialGuessAttributeCValue().intValue();
86        /**
87         * Get the initialGuess attribute value.
88         */
89        syn boolean FBooleanVariable.initialGuessAttribute() = initialGuessAttributeCValue().booleanValue();
90        /**
91         * Get the initialGuess attribute value.
92         */
93        syn String  FStringVariable.initialGuessAttribute()  = initialGuessAttributeCValue().stringValue();
94
95        /**
96         * Get the cost function expression.
97         *
98         * @return Cost function expression.
99         */
100        syn lazy FExp FOptClass.objectiveExp() {
101                for (FAttribute a : getFAttributes()) {
102                        if (a.getName().name().equals("objective")) {
103                                return a.hasValue()? a.getValue(): null;
104                        }
105                }
106                return null;
107        }
108
109        /**
110         * Get the integrand cost function expression.
111         *
112         * @return Cost function expression.
113         */
114        syn lazy FExp FOptClass.objectiveIntegrandExp() {
115                for (FAttribute a : getFAttributes()) {
116                        if (a.getName().name().equals("objectiveIntegrand")) {
117                                return a.hasValue()? a.getValue(): null;
118                        }
119                }
120                return null;
121        }
122       
123        /**
124         * Check if the startTime attribute is set.
125         *
126         * @return True if attribute set.
127         */
128        syn lazy boolean FOptClass.startTimeAttributeSet() {
129                for (FAttribute a : getFAttributes()) {
130                        if (a.getName().name().equals("startTime") && a.hasValue()) {
131                                return a.getAttributeSet();
132                        }
133                }
134                return false;
135        }
136               
137        /**
138         * Get the startTime attribute expression.
139         *
140         * @return Attribute expression or null if not set.
141         */
142        syn lazy FExp FOptClass.startTimeAttributeExp() {
143                for (FAttribute a : getFAttributes()) {
144                        if (a.getName().name().equals("startTime")) {
145                                return a.hasValue()? a.getValue(): null;
146                        }
147                }
148                return null;
149        }
150
151        /**
152         * Get the startTime attribute CValue.
153         *
154         * @return A CValue containing the evaluated attribute expression or
155         * 0.0 if not set.
156         */
157        syn CValue FOptClass.startTimeAttributeCValue() =
158                startTimeAttributeSet()? startTimeAttributeExp().ceval():
159                        CValueReal.valueOf(0.0);
160               
161        /**
162         * Get the startTime attribute value.
163         *
164         * @return Attribute value, 0.0 if attribute not set.
165         */     
166        syn double FOptClass.startTimeAttribute() = 
167                startTimeAttributeCValue().realValue();
168
169        /**
170         * Check if the free attribute of the startTime is set.
171         *
172         * @return True if attribute set.
173         */
174        syn lazy boolean FOptClass.startTimeFreeAttributeSet() {
175                for (FAttribute a : getFAttributes()) {
176                        if (a.getName().name().equals("startTime")) {
177                                for (FAttribute aa : a.getFAttributes()) {
178                                        if (aa.getName().name().equals("free")) {
179                                                return aa.getAttributeSet();
180                                        }
181                                }
182                        }
183                }
184                return false;
185        }
186               
187        /**
188         * Get the free attribute expression for startTime.
189         *
190         * @return Attribute expression or null if not set.
191         */
192        syn lazy FExp FOptClass.startTimeFreeAttributeExp() {
193                for (FAttribute a : getFAttributes()) {
194                        if (a.getName().name().equals("startTime")) {
195                                for (FAttribute aa : a.getFAttributes()) {
196                                        if (aa.getName().name().equals("free")) {
197                                                return aa.hasValue()? aa.getValue(): null;
198                                        }
199                                }
200                        }
201                }
202                return null;
203        }
204
205        /**
206         * Get the free attribute CValue of startTime.
207         *
208         * @return A CValue containing the evaluated attribute expression or
209         * false if not set.
210         */
211        syn CValue FOptClass.startTimeFreeAttributeCValue() =
212                startTimeFreeAttributeSet()? startTimeFreeAttributeExp().ceval():
213                        CValueBoolean.FALSE;
214               
215        /**
216         * Get the free attribute value for startTime.
217         *
218         * @return Attribute value, false if attribute not set.
219         */     
220        syn boolean FOptClass.startTimeFreeAttribute() = 
221                startTimeFreeAttributeCValue().booleanValue();
222
223        /**
224         * Check if the initialGuess attribute of the startTime is set.
225         *
226         * @return True if attribute set.
227         */
228        syn lazy boolean FOptClass.startTimeInitialGuessAttributeSet() {
229                for (FAttribute a : getFAttributes()) {
230                        if (a.getName().name().equals("startTime")) {
231                                for (FAttribute aa : a.getFAttributes()) {
232                                        if (aa.getName().name().equals("initialGuess")) {
233                                                return aa.getAttributeSet();
234                                        }
235                                }
236                        }
237                }
238                return false;
239        }
240               
241        /**
242         * Get the initialGuess attribute expression for startTime.
243         *
244         * @return Attribute expression or null if not set.
245         */
246        syn lazy FExp FOptClass.startTimeInitialGuessAttributeExp() {
247                for (FAttribute a : getFAttributes()) {
248                        if (a.getName().name().equals("startTime")) {
249                                for (FAttribute aa : a.getFAttributes()) {
250                                        if (aa.getName().name().equals("initialGuess")) {
251                                                return aa.hasValue()? aa.getValue(): null;
252                                        }
253                                }
254                        }
255                }
256                return null;
257        }
258
259        /**
260         * Get the initialGuess attribute CValue of startTime.
261         *
262         * @return A CValue containing the evaluated attribute expression or
263         * 0.0 if not set.
264         */
265        syn CValue FOptClass.startTimeInitialGuessAttributeCValue() =
266                startTimeInitialGuessAttributeSet()? startTimeInitialGuessAttributeExp().ceval():
267                        CValueReal.valueOf(0.0);
268               
269        /**
270         * Get the initialGuess attribute value for startTime.
271         *
272         * @return Attribute value, 0.0 if attribute not set.
273         */
274        syn double FOptClass.startTimeInitialGuessAttribute() = 
275                startTimeInitialGuessAttributeCValue().realValue();
276       
277        /**
278         * Check if the finalTime attribute is set.
279         *
280         * @return True if attribute set.
281         */
282        syn lazy boolean FOptClass.finalTimeAttributeSet() {
283                for (FAttribute a : getFAttributes()) {
284                        if (a.getName().name().equals("finalTime") && a.hasValue()) {
285                                return a.getAttributeSet();
286                        }
287                }
288                return false;
289        }
290               
291        /**
292         * Get the finalTime attribute expression.
293         *
294         * @return Attribute expression or null if not set.
295         */
296        syn lazy FExp FOptClass.finalTimeAttributeExp() {
297                for (FAttribute a : getFAttributes()) {
298                        if (a.getName().name().equals("finalTime")) {
299                                return a.hasValue()? a.getValue(): null;
300                        }
301                }
302                return null;
303        }
304
305        /**
306         * Get the finalTime attribute CValue.
307         *
308         * @return A CValue containing the evaluated attribute expression or
309         * 1.0 if not set.
310         */
311        syn CValue FOptClass.finalTimeAttributeCValue() =
312                finalTimeAttributeSet()? finalTimeAttributeExp().ceval():
313                        CValueReal.valueOf(1.0);
314               
315        /**
316         * Get the finalTime attribute value.
317         *
318         * @return Attribute value, 1.0 if attribute not set.
319         */     
320        syn double FOptClass.finalTimeAttribute() = 
321                finalTimeAttributeCValue().realValue();
322
323        /**
324         * Check if the static attribute is set.
325         *
326         * @return True if attribute set.
327         */
328        syn lazy boolean FOptClass.staticAttributeSet() {
329                for (FAttribute a : getFAttributes()) {
330                        if (a.getName().name().equals("static") && a.hasValue()) {
331                                return a.getAttributeSet();
332                        }
333                }
334                return false;
335        }
336               
337        /**
338         * Get the static attribute expression.
339         *
340         * @return Attribute expression or null if not set.
341         */
342        syn lazy FExp FOptClass.staticAttributeExp() {
343                for (FAttribute a : getFAttributes()) {
344                        if (a.getName().name().equals("static")) {
345                                return a.hasValue()? a.getValue(): null;
346                        }
347                }
348                return null;
349        }
350
351        /**
352         * Get the static attribute CValue.
353         *
354         * @return A CValue containing the evaluated attribute expression or
355         * false if not set.
356         */
357        syn CValue FOptClass.staticAttributeCValue() =
358                staticAttributeSet()? staticAttributeExp().ceval():
359                        CValueBoolean.FALSE;
360               
361        /**
362         * Get the static attribute value.
363         *
364         * @return Attribute value, false if attribute not set.
365         */     
366        syn boolean FOptClass.staticAttribute() = 
367                staticAttributeCValue().booleanValue();
368
369        /**
370         * Check if the free attribute of the finalTime is set.
371         *
372         * @return True if attribute set.
373         */
374        syn lazy boolean FOptClass.finalTimeFreeAttributeSet() {
375                for (FAttribute a : getFAttributes()) {
376                        if (a.getName().name().equals("finalTime")) {
377                                for (FAttribute aa : a.getFAttributes()) {
378                                        if (aa.getName().name().equals("free")) {
379                                                return aa.getAttributeSet();
380                                        }
381                                }
382                        }
383                }
384                return false;
385        }
386               
387        /**
388         * Get the free attribute expression for finalTime.
389         *
390         * @return Attribute expression or null if not set.
391         */
392        syn lazy FExp FOptClass.finalTimeFreeAttributeExp() {
393                for (FAttribute a : getFAttributes()) {
394                        if (a.getName().name().equals("finalTime")) {
395                                for (FAttribute aa : a.getFAttributes()) {
396                                        if (aa.getName().name().equals("free")) {
397                                                return aa.hasValue()? aa.getValue(): null;
398                                        }
399                                }
400                        }
401                }
402                return null;
403        }
404
405        /**
406         * Get the free attribute CValue for finalTime.
407         *
408         * @return A CValue containing the evaluated attribute expression or
409         * false if not set.
410         */
411        syn CValue FOptClass.finalTimeFreeAttributeCValue() =
412                finalTimeFreeAttributeSet()? finalTimeFreeAttributeExp().ceval():
413                        CValueBoolean.FALSE;
414
415        /**
416         * Get the free attribute value for finalTime.
417         *
418         * @return Attribute value, false if attribute not set.
419         */             
420        syn boolean FOptClass.finalTimeFreeAttribute() = 
421                finalTimeFreeAttributeCValue().booleanValue();
422       
423        /**
424         * Check if the initialGuess attribute of the finalTime is set.
425         *
426         * @return True if attribute set.
427         */
428        syn lazy boolean FOptClass.finalTimeInitialGuessAttributeSet() {
429                for (FAttribute a : getFAttributes()) {
430                        if (a.getName().name().equals("finalTime")) {
431                                for (FAttribute aa : a.getFAttributes()) {
432                                        if (aa.getName().name().equals("initialGuess")) {
433                                                return aa.getAttributeSet();
434                                        }
435                                }
436                        }
437                }
438                return false;
439        }
440               
441        /**
442         * Get the initialGuess attribute expression for finalTime.
443         *
444         * @return Attribute expression or null if not set.
445         */
446        syn lazy FExp FOptClass.finalTimeInitialGuessAttributeExp() {
447                for (FAttribute a : getFAttributes()) {
448                        if (a.getName().name().equals("finalTime")) {
449                                for (FAttribute aa : a.getFAttributes()) {
450                                        if (aa.getName().name().equals("initialGuess")) {
451                                                return aa.hasValue()? aa.getValue(): null;
452                                        }
453                                }
454                        }
455                }
456                return null;
457        }
458
459        /**
460         * Get the initialGuess attribute CValue for finalTime.
461         *
462         * @return A CValue containing the evaluated attribute expression or
463         * 1.0 if not set.
464         */
465        syn CValue FOptClass.finalTimeInitialGuessAttributeCValue() =
466                finalTimeInitialGuessAttributeSet()? finalTimeInitialGuessAttributeExp().ceval():
467                        CValueReal.valueOf(1.0);
468               
469        /**
470         * Get the initialGuess attribute value for finalTime.
471         *
472         * @return Attribute value, 1.0 if attribute not set.
473         */     
474        syn double FOptClass.finalTimeInitialGuessAttribute() = 
475                finalTimeInitialGuessAttributeCValue().realValue();
476       
477       
478        eq FOptClass.getChild().isInFV()                        = false;
479        eq FOptClass.getChild().isInFV(FVariable fv)            = false;
480        eq FOptClass.getChild().isInDerivedType()               = false;
481        eq FOptClass.getChild().isInDerivedType(FDerivedType t) = false;
482       
483       
484
485        /**
486         * Get the number of Constraints.
487         */
488    syn int FOptClass.numConstraints() = constraints().size();
489   
490    /**
491     * Get a list of all constraints.
492     */
493        coll ArrayList<FConstraint> FOptClass.constraints() 
494          [new ArrayList<FConstraint>()] with add root FClass;
495        FRelationConstraint contributes this to FOptClass.constraints() for myFClass();
496       
497        /**
498         * Get the number of equality constraints.
499         */
500    syn int FOptClass.numEqConstraints() = eqConstraints().size();
501       
502    /**
503     * Get a list of equality constraints.
504     */
505    coll ArrayList<FConstraint> FOptClass.eqConstraints() 
506          [new ArrayList<FConstraint>()] with add root FClass;
507        FConstraint contributes
508                this when isEqConstraint()
509        to FOptClass.eqConstraints() for myFClass();
510
511        /**
512         * Get the number of LEQ constraints.
513         */
514    syn int FOptClass.numLeqConstraints() = leqConstraints().size();
515
516        /**
517         * Get a list of LEQ constraints.
518         */
519    coll ArrayList<FConstraint> FOptClass.leqConstraints() 
520          [new ArrayList<FConstraint>()] with add root FClass;
521        FConstraint contributes
522                this when isLeqConstraint()
523        to FOptClass.leqConstraints() for myFClass();
524
525        /**
526         * Get the number of GEQ constraints.
527         */
528    syn int FOptClass.numGeqConstraints() = geqConstraints().size();
529       
530        /**
531         * Get the number of GEQ constraints.
532         */
533    coll ArrayList<FConstraint> FOptClass.geqConstraints() 
534          [new ArrayList<FConstraint>()] with add root FClass;
535        FConstraint contributes
536                this when isGeqConstraint()
537        to FOptClass.geqConstraints() for myFClass();   
538
539        /**
540         * Get the number of path constraints.
541         */
542    syn int FOptClass.numPathConstraints() = pathConstraints().size();
543
544        /**
545         * Get a list of path constraints.
546         */
547    syn lazy ArrayList<FConstraint> FOptClass.pathConstraints() {
548        ArrayList<FConstraint> list = new ArrayList<FConstraint>();
549                list.addAll(pathEqConstraints());
550                list.addAll(pathLeqConstraints());
551                list.addAll(pathGeqConstraints());
552        return list;
553    }
554
555        /**
556         * Get the number of equality path constraints.
557         */
558    syn int FOptClass.numPathEqConstraints() = pathEqConstraints().size();
559
560        /**
561         * Get a list of equality path constraints.
562         */
563    syn lazy ArrayList<FConstraintEq> FOptClass.pathEqConstraints() {
564        ArrayList<FConstraintEq> list = new ArrayList<FConstraintEq>();
565        for (FConstraint c : eqConstraints()) {
566                if (!c.isTimed() && !c.isParameter()){
567                        list.add((FConstraintEq)c);
568                }
569        }
570        return list;
571    }
572
573        /**
574         * Get the number of LEQ path constraints.
575         */
576    syn int FOptClass.numPathLeqConstraints() = pathLeqConstraints().size();
577   
578        /**
579         * Get a list of LEQ path constraints.
580         */
581    syn lazy ArrayList<FConstraintLeq> FOptClass.pathLeqConstraints() {
582        ArrayList<FConstraintLeq> list = new ArrayList<FConstraintLeq>();
583        for (FConstraint c : leqConstraints()) {
584                if (!c.isTimed() && !c.isParameter()){
585                        list.add((FConstraintLeq)c);
586                }
587        }
588        return list;
589    }
590
591        /**
592         * Get the number of GEQ path constraints.
593         */
594    syn int FOptClass.numPathGeqConstraints() = pathGeqConstraints().size();
595   
596        /**
597         * Get a list of GEQ path constraints.
598         */
599    syn lazy ArrayList<FConstraintGeq> FOptClass.pathGeqConstraints() {
600        ArrayList<FConstraintGeq> list = new ArrayList<FConstraintGeq>();
601        for (FConstraint c : geqConstraints()) {
602                if (!c.isTimed() && !c.isParameter()){
603                        list.add((FConstraintGeq)c);
604                }
605        }
606        return list;
607    }
608
609        /**
610         * Get the number of point constraints.
611         */
612    syn int FOptClass.numPointConstraints() = pointConstraints().size();
613
614        /**
615         * Get a list of point constraints.
616         */
617    syn lazy ArrayList<FConstraint> FOptClass.pointConstraints() {
618        ArrayList<FConstraint> list = new ArrayList<FConstraint>();
619                list.addAll(pointEqConstraints());
620                list.addAll(pointLeqConstraints());
621                list.addAll(pointGeqConstraints());
622        return list;
623    }
624
625        /**
626         * Get the number of equality point constraints.
627         */
628    syn int FOptClass.numPointEqConstraints() = pointEqConstraints().size();
629
630        /**
631         * Get a list of equality point constraints.
632         */
633    syn lazy ArrayList<FConstraintEq> FOptClass.pointEqConstraints() {
634        ArrayList<FConstraintEq> list = new ArrayList<FConstraintEq>();
635        for (FConstraint c : eqConstraints()) {
636                if (c.isTimed() || c.isParameter()){
637                        list.add((FConstraintEq)c);
638                }
639        }
640        return list;
641    }
642
643        /**
644         * Get the number of LEQ point constraints.
645         */
646    syn int FOptClass.numPointLeqConstraints() = pointLeqConstraints().size();
647 
648        /**
649         * Get a list of LEQ point constraints.
650         */
651    syn lazy ArrayList<FConstraintLeq> FOptClass.pointLeqConstraints() {
652        ArrayList<FConstraintLeq> list = new ArrayList<FConstraintLeq>();
653        for (FConstraint c : leqConstraints()) {
654                if (c.isTimed() || c.isParameter()){
655                        list.add((FConstraintLeq)c);
656                }
657        }
658        return list;
659    }
660
661        /**
662         * Get the number of GEQ point constraints.
663         */
664    syn int FOptClass.numPointGeqConstraints() = pointGeqConstraints().size();
665   
666        /**
667         * Get a list of GEQ point constraints.
668         */
669    syn lazy ArrayList<FConstraintGeq> FOptClass.pointGeqConstraints() {
670        ArrayList<FConstraintGeq> list = new ArrayList<FConstraintGeq>();
671        for (FConstraint c : geqConstraints()) {
672                if (c.isTimed() || c.isParameter()){
673                        list.add((FConstraintGeq)c);
674                }
675        }
676        return list;
677    }
678       
679    /**
680     * Returns true for equality constraints.
681     */
682        syn boolean FConstraint.isEqConstraint() = false;
683        eq FConstraintEq.isEqConstraint() = true;
684
685    /**
686     * Returns true for LEQ constraints.
687     */
688        syn boolean FConstraint.isLeqConstraint() = false;
689        eq FConstraintLeq.isLeqConstraint() = true;
690
691    /**
692     * Returns true for GEQ constraints.
693     */
694        syn boolean FConstraint.isGeqConstraint() = false;
695        eq FConstraintGeq.isGeqConstraint() = true;
696                       
697    /**
698     * Get the number of timed variables.
699     */
700        syn int FOptClass.numTimedVariables() = timedVariables().size();
701       
702    /**
703     * Get the a list of timed variables.
704     */
705        coll ArrayList<FTimedVariable> FOptClass.timedVariables() 
706                [new ArrayList<FTimedVariable>()] with add root FClass;
707        FTimedVariable contributes
708            this
709        to FOptClass.timedVariables() for myFClass();
710
711    /**
712     * Get the number of real timed variables.
713     */
714        syn int FOptClass.numTimedRealVariables() = timedRealVariables().size();
715
716    /**
717     * Get the a list of real timed variables.
718     */
719        syn lazy ArrayList<FTimedVariable> FOptClass.timedRealVariables() {
720                ArrayList<FTimedVariable> list = new ArrayList<FTimedVariable>();
721                for (FTimedVariable tv : timedVariables()) {
722                        if (tv.getName().myFV().isReal()) {
723                                list.add(tv);
724                        }
725                }
726                return list;
727        }
728               
729        inh FClass FConstraint.myFClass();
730
731    /**
732     * Get the number of time points.
733     */
734        syn int FOptClass.numTimePointsExp() = timePointsExp().size();
735       
736    /**
737     * Get a list of time point expressions.
738     */
739        syn ArrayList<FExp> FOptClass.timePointsExp() {
740                ArrayList<FExp> list = new ArrayList<FExp>();
741                for (FTimedVariable tv : timedVariables()) {
742                        list.add(tv.getArg());
743                }
744                return list;           
745        }
746       
747    /**
748     * Get the number of (unique) time points.
749     */
750        syn int FOptClass.numTimePoints() = timePoints().length;
751       
752    /**
753     * Get a sorted vector of unique time points.
754     */
755        syn lazy double[] FOptClass.timePoints() {
756                ArrayList<Double> ts = new ArrayList<Double>();
757                for (FExp t : timePointsExp()) {
758                        ts.add(new Double(t.ceval().realValue()));
759                }
760                if (ts.size()==0) {
761                        return new double[0];
762                }
763                java.util.Collections.sort(ts);
764                ArrayList<Double> ts_unique = new ArrayList<Double>();
765                ts_unique.add(ts.get(0));
766                double tt = ts.get(0).doubleValue();
767                for (int i=1;i<ts.size();i++) {
768                        if (ts.get(i)>tt) {
769                                ts_unique.add(ts.get(i));
770                                tt = ts.get(i).doubleValue();
771                        }
772                }
773                double[] tts = new double[ts_unique.size()];
774                for (int i=0;i<ts_unique.size();i++) {
775                        tts[i] = ts_unique.get(i).doubleValue();
776                }
777                return tts;
778        }
779
780        /**
781         * Get the index of a time point.
782         *
783         * @param t Time point
784         * @return Time point index. Returns -1 if time point not found.
785         */
786        syn lazy int FOptClass.timePointIndex(double t) {
787                for (int i=0;i<timePoints().length;i++) {
788                        if (timePoints()[i]==t) {
789                                return i;
790                        }
791                }
792                return -1;
793        }
794       
795        syn lazy ArrayList<FVariable> FOptClass.timePointFVariables(double t) {
796                HashSet<FVariable> s = new HashSet<FVariable>();
797                for (FTimedVariable tp : timedVariables()) {
798                        if (tp.getArg().ceval().realValue() == t) {
799                                s.add((FVariable)tp.getName().myFV()); 
800                        }
801                }
802                ArrayList<FVariable> l = new  ArrayList<FVariable>();
803                l.addAll(s);
804                return l;
805        }
806       
807        inh FOptClass FAbstractVariable.myFOptClass();
808        inh FOptClass FExp.myFOptClass();
809        inh FOptClass CommonAccess.myFOptClass();
810        inh FOptClass InstComponentModification.myFOptClass();
811        eq FOptClass.getChild().myFOptClass() = this;
812        eq Root.getChild().myFOptClass() = null; 
813   
814    inh boolean FAbstractVariable.inOptimization();
815    inh boolean FExp.inOptimization();
816    inh boolean CommonAccess.inOptimization();
817    inh boolean InstComponentModification.inOptimization();
818    eq FOptClass.getChild().inOptimization() = true;
819    eq Root.getChild().inOptimization()      = false; 
820   
821    inh boolean CommonAccessExp.inObjective();
822    eq FAttribute.getValue().inObjective() = isObjective();
823    eq Root.getChild().inObjective()       = false;
824   
825    syn boolean FAttribute.isObjective() = getName().name().equals("objective");
826       
827        syn boolean SrcRestriction.isOptimizationClass() = false;
828        eq SrcOptimizationClass.isOptimizationClass() = true;
829        syn boolean SrcClassDecl.isOptimizationClass() = false;
830        eq SrcBaseClassDecl.isOptimizationClass() = getSrcRestriction().isOptimizationClass();
831        syn boolean InstClassDecl.isOptimizationClass() = getSrcClassDecl().isOptimizationClass();
832       
833        eq FOptClass.getFAttribute().size() = Size.SCALAR;
834       
835}
836
837aspect OptimicaFVariableUses {
838       
839        /**
840         * Collection attribute returning all variable uses in timed
841         * variables.
842         */
843        coll HashSet<FTimedVariable> FVariable.usesTimedVariables() 
844          [new HashSet<FTimedVariable>()] 
845           with add root FClass;
846       
847        FTimedVariable contributes this to
848           FVariable.usesTimedVariables() for getName().myFV();
849               
850}
851
852aspect OptimicaLinearVariables {
853       
854        refine FlatAPI eq FVariable.isLinear() {
855                if (variability().fixedParameterOrLess() && !(isOptParameter() | isDependentFreeParameter())) {
856                        return true;
857                } 
858                for (CommonAccessExp e : uses()) {
859                        if (!e.isLinear()) {
860                                return false;
861                        }
862                }
863                return true;
864        }
865       
866        refine LinearFVariables eq FExp.isLinearParameterExp() = isParameterExp() && !isOptParameterExp();
867       
868        /**
869         * Linearity of timed variables.
870         *
871         * The returned vector of booleans corresponds to linearity of the
872         * FVariable at each time point included in the optimization problem.
873         * Notice that this method differs from FClass.isLinear(). FClass.isLinear()
874         * returns the linearity of a variables derived by looking only at its
875         * corresponding identifiers (in binding equations, initial equations and
876         * equations) excluding timed variables. FOptClass.isLinearTimedVariables()
877         * on the other hand is derived based only on timed variables. The
878         * ordering of the entries of the returned vector is the same as the
879         * one given by the method FOptClass.timePointIndex().
880         *
881         * @return A vector of booleans corresponding to the linearity of timed
882         * variable occurances. Each entry is true if the timed variable(s) for
883         * the corresponding time point all occurs linearly, otherwise false.
884         */
885        syn lazy boolean[] FVariable.isLinearTimedVariables() {
886                boolean isLin[] = new boolean[myFOptClass().numTimePoints()];
887                for (int i=0;i<myFOptClass().numTimePoints();i++) {
888                        isLin[i] = true;
889                }
890                for (FTimedVariable ftv : usesTimedVariables()) {
891                        if (!ftv.isLinear()) {
892                                isLin[myFOptClass().timePointIndex(ftv.getArg().ceval().realValue())] = false;
893                        }
894                }
895                return isLin;
896        }
897       
898}
899
900aspect OptimicaFlatAPIDiagnostics {
901
902        /**
903         * Print diagnostics for FOptClass.
904         */
905        public String FOptClass.diagnostics() {
906                StringBuilder str = new StringBuilder();
907                str.append(super.diagnostics() + "\n");
908                str.append("Cost function:   ");
909                if (objectiveExp()!=null) {
910                        str.append(objectiveExp()!=null? objectiveExp().prettyPrint("") + "\n": "");
911                } else {
912                        str.append(" not give\n");
913                }
914                str.append("Cost function integrand:   ");
915                if (objectiveIntegrandExp()!=null) {
916                        str.append(objectiveIntegrandExp()!=null? objectiveIntegrandExp().prettyPrint("") + "\n": "");
917                } else {
918                        str.append(" not give\n");
919                }
920                str.append("startTime:       " + (startTimeAttributeSet()? startTimeAttributeExp().prettyPrint(""): "not set") + "\n");
921                str.append("startTime free:  " + (startTimeFreeAttributeSet()? startTimeFreeAttributeExp().prettyPrint(""): "not set") + "\n");
922                str.append("startTime init:  " + (startTimeInitialGuessAttributeSet()? startTimeInitialGuessAttributeExp().prettyPrint(""): "not set") + "\n");
923                str.append("finalTime:       " + (finalTimeAttributeSet()? finalTimeAttributeExp().prettyPrint(""): "not set") + "\n");
924                str.append("finalTime free:  " + (finalTimeFreeAttributeSet()? finalTimeFreeAttributeExp().prettyPrint(""): "not set") + "\n");
925                str.append("finalTime init:  " + (finalTimeInitialGuessAttributeSet()? finalTimeInitialGuessAttributeExp().prettyPrint(""): "not set") + "\n");
926                str.append("\n");
927                str.append("Number of timed real variables: " + numTimedRealVariables() + "\n");
928                str.append("Timed real variables: {");
929                for (FTimedVariable tv : timedRealVariables()) {
930                        str.append(tv.prettyPrint("") + " ");
931                }
932                str.append("}\n");
933                str.append("Number of time points: " + numTimePoints() + "\n");
934                str.append("Time points: {");
935                for (int i=0;i<numTimePoints();i++) {
936                        str.append(timePoints()[i] + " ");
937                }
938                str.append("}\n\n");
939               
940                str.append("Path Equality Constraints: {\n");
941                for (FConstraint c : pathEqConstraints()) {
942                        str.append(c.prettyPrint("  "));
943                        str.append("\n");
944                }
945                str.append("}\n");
946
947                str.append("Path Leq Constraints: {\n");
948                for (FConstraint c : pathLeqConstraints()) {
949                        str.append(c.prettyPrint("  "));
950                        str.append("\n");
951                }
952                str.append("}\n");
953
954                str.append("Path Geq Constraints: {\n");
955                for (FConstraint c : pathGeqConstraints()) {
956                        str.append(c.prettyPrint("  "));
957                        str.append("\n");
958                }
959                str.append("}\n");
960
961                str.append("Point Equality Constraints: {\n");
962                for (FConstraint c : pointEqConstraints()) {
963                        str.append(c.prettyPrint("  "));
964                        str.append("\n");
965                }
966                str.append("}\n");
967
968                str.append("Point Leq Constraints: {\n");
969                for (FConstraint c : pointLeqConstraints()) {
970                        str.append(c.prettyPrint("  "));
971                        str.append("\n");
972                }
973                str.append("}\n");
974
975                str.append("Point Geq Constraints: {\n");
976                for (FConstraint c : pointGeqConstraints()) {
977                        str.append(c.prettyPrint("  "));
978                        str.append("\n");
979                }
980                str.append("}\n");
981
982                str.append("\n");
983                str.append(timedVariablesLinearityDiagnostics());
984
985                str.append("\n");
986                str.append(freeParametersDiagnostics());               
987               
988                return str.toString();
989        }       
990       
991        /**
992         * Returns a string containing information of timed variable
993         * linearity.
994         */
995        public String FOptClass.timedVariablesLinearityDiagnostics() {
996                StringBuilder str = new StringBuilder();
997                str.append("Linearity of time points:\n");
998                for (FVariable fv : getFVariables()) {
999                        str.append(fv.name() + ":\n");
1000                        boolean isLin[] = fv.isLinearTimedVariables();
1001                        for (int i=0;i<numTimePoints();i++) {
1002                                str.append("  " + timePoints()[i] + ", isLinear: " +
1003                                                isLin[i] + "\n");
1004                        }
1005                }
1006               
1007                return str.toString();
1008        }
1009       
1010        public String FOptClass.freeParametersDiagnostics() {
1011                StringBuilder str = new StringBuilder();
1012                str.append("Free independent parameters:\n");
1013                for (FVariable v : freeIndependentParameters()) {
1014                        str.append(v.name()+"\n");
1015                }
1016                str.append("Free dependent parameters:\n");
1017                        for (FVariable v : freeDependentParameters()) {
1018                                str.append(v.name()+"\n");
1019                        }
1020                return str.toString();
1021        }
1022}
1023
1024aspect OptimicaFreeParameters {
1025
1026    refine FlatAPI eq FVariable.zVariability() {
1027        if (isIndependentFreeParameter() || isDependentFreeParameter()) {
1028            return FClass.ZVariability.FREE_PARAMETER;
1029        } else {
1030            return refined();
1031        }
1032    }
1033
1034    syn boolean FAbstractVariable.isFreeParameter() = false;
1035    eq FVariable.isFreeParameter() = zVariability() == FClass.ZVariability.FREE_PARAMETER;
1036    syn boolean FVariable.isIndependentFreeParameter() = freeAttribute() && isIndependentParameter();
1037    syn boolean FVariable.isDependentFreeParameter() = isDependentParameter() &&
1038            (freeAttribute() || myFClass().parametersDependingOnFreeParameters().contains(this));
1039
1040    /**
1041     * Helper for FAbstractVariable.isDependentFreeParameter().
1042     */
1043    syn lazy LinkedHashSet<FVariable> FClass.parametersDependingOnFreeParameters() {
1044        LinkedHashSet<FVariable> s = new LinkedHashSet<FVariable>();
1045        // Retrieve the dependent parameters that depends directly on
1046        // free independent parameters.
1047        for (FVariable v : getFVariables()) {
1048            // Can't use freeIndependentParameters() here, it results in recursive loop.
1049            if (v.isIndependentFreeParameter()) {
1050                s.addAll(v.dependentParameters());
1051            }
1052        }
1053        // Fixed point iteration over the dependent parameters.
1054        int n_dp = -1;
1055        LinkedHashSet<FVariable> s_tmp = new LinkedHashSet<FVariable>();
1056        while (n_dp != s.size()) {
1057            n_dp = s.size();
1058            for (FVariable v : s) {
1059                s_tmp.addAll(v.dependentParameters());
1060            }
1061            s.addAll(s_tmp);
1062        }
1063        return s;
1064    }
1065
1066
1067       
1068    syn int FClass.numFreeIndependentParameters() = freeIndependentParameters().size();
1069    syn Collection<FVariable> FClass.freeIndependentParameters() = varRefMap().getBy(ParaDependency.INDEPENDENT, ZVariability.FREE_PARAMETER);
1070
1071    syn int FClass.numFreeIndependentRealParameters() = freeIndependentRealParameters().size();
1072    syn Collection<FVariable> FClass.freeIndependentRealParameters() = varRefMap().getBy(ZOrdinaryCategory.INDEPENDENT_REAL_FREE_PARAMETER);
1073
1074    syn int FClass.numFreeIndependentIntegerParameters() = freeIndependentIntegerParameters().size();
1075    syn Collection<FVariable> FClass.freeIndependentIntegerParameters() = varRefMap().getBy(ZOrdinaryCategory.INDEPENDENT_INTEGER_FREE_PARAMETER);
1076
1077    syn int FClass.numFreeIndependentEnumParameters() = freeIndependentEnumParameters().size();
1078    syn Collection<FVariable> FClass.freeIndependentEnumParameters() = varRefMap().getBy(ZOrdinaryCategory.INDEPENDENT_ENUM_FREE_PARAMETER);
1079
1080    syn int FClass.numFreeIndependentBooleanParameters() = freeIndependentBooleanParameters().size();
1081    syn Collection<FVariable> FClass.freeIndependentBooleanParameters() = varRefMap().getBy(ZOrdinaryCategory.INDEPENDENT_BOOLEAN_FREE_PARAMETER);
1082
1083    syn int FClass.numFreeDependentParameters() = freeDependentParameters().size();
1084    syn Collection<FVariable> FClass.freeDependentParameters() = varRefMap().getBy(ParaDependency.DEPENDENT, ZVariability.FREE_PARAMETER);
1085   
1086       
1087        /**
1088         * Get a list of the equations of all dependent parameters that depends on free parameters.
1089         */
1090        syn lazy LinkedHashSet<FAbstractEquation> FClass.freeDependentParameterEquations() {
1091                LinkedHashSet<FAbstractEquation> s = new LinkedHashSet<FAbstractEquation>();
1092                for (FVariable v : freeDependentParameters()) {
1093                        s.add(v.parameterEquation());
1094                }
1095                return s;
1096        }
1097       
1098        syn int FClass.numFreeDependentRealParameters() = freeDependentRealParameters().size();
1099        syn Collection<FVariable> FClass.freeDependentRealParameters() = varRefMap().getBy(ZOrdinaryCategory.DEPENDENT_REAL_FREE_PARAMETER);
1100       
1101        coll LinkedHashSet<FVariable> FAbstractEquation.retrieveFreeParameters() 
1102                [new LinkedHashSet<FVariable>()] with add root FAbstractEquation;
1103
1104        FAccessExp contributes (FVariable)myFV() when !myFV().isUnknown() && 
1105                !(getParent() instanceof FDerExp) && !(getParent() instanceof FPreExp) && 
1106                myFV().isFreeParameter() to
1107                FAbstractEquation.retrieveFreeParameters() for myFEquation();
1108
1109        syn lazy LinkedHashSet<FVariable> FAbstractEquation.freeParameters() = 
1110            retrieveFreeParameters();
1111       
1112        eq FWhenEquation.freeParameters()  {
1113                LinkedHashSet<FVariable> s = new LinkedHashSet<FVariable>();
1114                s.addAll(retrieveFreeParameters());
1115                for (FAbstractEquation e : getFAbstractEquations()) {
1116                        s.addAll(e.freeParameters());
1117                }
1118                return s;
1119        }
1120
1121        syn lazy Collection<FVariable> FAbstractEquation.realFreeParameters() = 
1122                FClass.filterCollection(freeParameters(), FClass.REAL_VARIABLE_FILTER);
1123       
1124}
Note: See TracBrowser for help on using the repository browser.