Menu
▾
▴
sbml-arrays — The SBML L3 Arrays and Sets package discussion list
You can subscribe to this list here.
| 2012 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
|
Oct
|
Nov
|
Dec
(1) |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2013 |
Jan
|
Feb
|
Mar
|
Apr
(2) |
May
|
Jun
|
Jul
|
Aug
|
Sep
(10) |
Oct
(27) |
Nov
|
Dec
(6) |
| 2014 |
Jan
(25) |
Feb
|
Mar
(44) |
Apr
(21) |
May
(1) |
Jun
(7) |
Jul
(3) |
Aug
(18) |
Sep
(7) |
Oct
(1) |
Nov
|
Dec
|
| 2015 |
Jan
|
Feb
|
Mar
|
Apr
(9) |
May
|
Jun
|
Jul
|
Aug
|
Sep
(15) |
Oct
|
Nov
|
Dec
|
| 2017 |
Jan
|
Feb
|
Mar
|
Apr
|
May
(31) |
Jun
(4) |
Jul
(9) |
Aug
|
Sep
|
Oct
|
Nov
|
Dec
|
| 2018 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
(1) |
Sep
(2) |
Oct
|
Nov
|
Dec
|
|
From: Chris J. M. <my...@ec...> - 2014-09-03 23:19:06
|
Guess I'm still missing it. Just to be clear. Arrays are not equal to matrices. All math is done element-wise. This was a decision we made to keep the first version simple. If this is okay, can you make the example more concrete with some very simple idea of what the model would look like? Chris On Sep 3, 2014, at 4:55 PM, Andy Somogyi <and...@gm...> wrote: > The application I have mind is would be a synapse model. Here the probability of a vesicle release would be calculated as a convolution of a set of state variables historical values for a finite window of time. > > In effect you can think of it as a sliding window moving average. > > So, here this value actually determines the models dynamics so it would be part of the model and not analysis. > > It would be possible to get this kind of behavior today by explicitly writing out the convolution when writing the model. But I think the array package would be ideal for this as you could write these in a very concise and general and flexible way. > > On Wednesday, September 3, 2014, Chris J. Myers <my...@ec...> wrote: > Sounds like an interesting application. You can certainly create a parameter which is an array to store data. However, the question would be can you express the storing of the historical data you want using events or rules. I think you may be able to as these are pretty powerful, but I'm not sure I understand your application well enough to tell you how to do it. The question I have though is if what you are proposing is part of the model or part of its analysis. I agree the line can blur at times, but it should be considered. > > Cheers, > > Chris > > On Sep 3, 2014, at 10:01 AM, Andy Somogyi <and...@gm...> wrote: > > > Hello, > > > > Frequently, one needs to perform an array like operation on historical data, such as convolution of history with an array. Or some other array operation, such as summing or integrating historical data. > > > > What would be very useful is if specification allowed historical time series when a delay equation is specified to be use as an array in conjunction with various array functions specified in the arrays package. > > > > > > > > ------------------------------------------------------------------------------ > > Slashdot TV. > > Video for Nerds. Stuff that matters. > > http://tv.slashdot.org/ > > _______________________________________________ > > sbml-arrays mailing list > > sbm...@li... > > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > > ------------------------------------------------------------------------------ > Slashdot TV. > Video for Nerds. Stuff that matters. > http://tv.slashdot.org/ > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > ------------------------------------------------------------------------------ > Slashdot TV. > Video for Nerds. Stuff that matters. > http://tv.slashdot.org/_______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays |
|
From: Andy S. <and...@gm...> - 2014-09-03 22:55:22
|
The application I have mind is would be a synapse model. Here the probability of a vesicle release would be calculated as a convolution of a set of state variables historical values for a finite window of time. In effect you can think of it as a sliding window moving average. So, here this value actually determines the models dynamics so it would be part of the model and not analysis. It would be possible to get this kind of behavior today by explicitly writing out the convolution when writing the model. But I think the array package would be ideal for this as you could write these in a very concise and general and flexible way. On Wednesday, September 3, 2014, Chris J. Myers <my...@ec...> wrote: > Sounds like an interesting application. You can certainly create a > parameter which is an array to store data. However, the question would be > can you express the storing of the historical data you want using events or > rules. I think you may be able to as these are pretty powerful, but I'm > not sure I understand your application well enough to tell you how to do > it. The question I have though is if what you are proposing is part of the > model or part of its analysis. I agree the line can blur at times, but it > should be considered. > > Cheers, > > Chris > > On Sep 3, 2014, at 10:01 AM, Andy Somogyi <and...@gm... > <javascript:;>> wrote: > > > Hello, > > > > Frequently, one needs to perform an array like operation on historical > data, such as convolution of history with an array. Or some other array > operation, such as summing or integrating historical data. > > > > What would be very useful is if specification allowed historical time > series when a delay equation is specified to be use as an array in > conjunction with various array functions specified in the arrays package. > > > > > > > > > ------------------------------------------------------------------------------ > > Slashdot TV. > > Video for Nerds. Stuff that matters. > > http://tv.slashdot.org/ > > _______________________________________________ > > sbml-arrays mailing list > > sbm...@li... <javascript:;> > > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > > > ------------------------------------------------------------------------------ > Slashdot TV. > Video for Nerds. Stuff that matters. > http://tv.slashdot.org/ > _______________________________________________ > sbml-arrays mailing list > sbm...@li... <javascript:;> > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > |
|
From: Chris J. M. <my...@ec...> - 2014-09-03 21:43:32
|
Sounds like an interesting application. You can certainly create a parameter which is an array to store data. However, the question would be can you express the storing of the historical data you want using events or rules. I think you may be able to as these are pretty powerful, but I'm not sure I understand your application well enough to tell you how to do it. The question I have though is if what you are proposing is part of the model or part of its analysis. I agree the line can blur at times, but it should be considered. Cheers, Chris On Sep 3, 2014, at 10:01 AM, Andy Somogyi <and...@gm...> wrote: > Hello, > > Frequently, one needs to perform an array like operation on historical data, such as convolution of history with an array. Or some other array operation, such as summing or integrating historical data. > > What would be very useful is if specification allowed historical time series when a delay equation is specified to be use as an array in conjunction with various array functions specified in the arrays package. > > > > ------------------------------------------------------------------------------ > Slashdot TV. > Video for Nerds. Stuff that matters. > http://tv.slashdot.org/ > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays |
|
From: Andy S. <and...@gm...> - 2014-09-03 16:02:01
|
Hello, Frequently, one needs to perform an array like operation on historical data, such as convolution of history with an array. Or some other array operation, such as summing or integrating historical data. What would be very useful is if specification allowed historical time series when a delay equation is specified to be use as an array in conjunction with various array functions specified in the arrays package. |
|
From: Bruce S. <bru...@gm...> - 2014-08-13 19:18:46
|
Sounds reasonable to me. Sent by an Android from another Galaxy. On Aug 13, 2014 11:36 AM, "Lucian Smith" <luc...@gm...> wrote: > Right, I am claiming that even if SBML arrays are officially static, they > can be used in non-static contexts (such as parameter scan-like functions > in tools, and in hierarchical models), and therefore should behave more > like lists than arrays. > > When they are zero-length, they would, like empty lists, be equivalent to > not including it in the model at all, except that references to it would be > allowed. > > -Lucian > > > On Wed, Aug 13, 2014 at 11:18 AM, Bruce Shapiro <bru...@gm... > > wrote: > >> I still don't understand how there would be an array parameter of zero >> length in a model. Are you saying that something might or might not exist >> in the model, and that zero length means it does not exist? >> >> >> On Wed, Aug 13, 2014 at 11:09 AM, Lucian Smith <luc...@gm... >> > wrote: >> >>> There might be the case where the SBML model is under control of some >>> other force, such as SED-ML or another simulation tool. A parameter scan, >>> for example, does not require the parameter being scanned to be >>> non-constant, but various different values are used for it over the course >>> of several experiments, in each of which the parameter in question is >>> constant. I can imagine a similar situation here, where someone is testing >>> the behavior of a model under different circumstances, the simplest of >>> which has a zero-sized array. >>> >>> Even within-SBML, one might have a hierarchical model where a submodel >>> has a zero-sized array that becomes longer when imported and changed, or >>> visa versa. >>> >>> I would say that since it doesn't seem terribly difficult to support, >>> has a clear meaning, and is potentially useful, that we allow it. >>> >>> -Lucian >>> >>> >>> On Wed, Aug 13, 2014 at 11:00 AM, Chris J. Myers <my...@ec...> >>> wrote: >>> >>>> I think in programming languages, there is often a difference between a >>>> zero-size array and a null pointer. You can use zero-size arrays as an >>>> initialization value, so you don't need to check for null all the time. >>>> However, this is with the assumption that you can later change the size of >>>> the array and add things to it. >>>> >>>> For arrays package with SBML, we made the decision that these would be >>>> static-size arrays. Therefore, a zero-size array will always be a >>>> zero-size array, and when this gets flattened to SBML core, the object is >>>> simply removed entirely. So, is such a behavior useful or simply create an >>>> unnecessary complication? >>>> >>>> Chris >>>> >>>> On Aug 13, 2014, at 11:06 AM, Bruce Shapiro <bru...@gm...> >>>> wrote: >>>> >>>> Do any computer languages allow this? Isn't there already a symbol for >>>> the empty set for this this that one would normally use instead? Nil null >>>> bupkis >>>> >>>> Sent by an Android from another Galaxy. >>>> On Aug 13, 2014 9:41 AM, "Chris J. Myers" <my...@ec...> wrote: >>>> >>>>> Hi, >>>>> >>>>> We were wondering if anyone sees a use for zero size arrays. When you >>>>> declare something as zero-szie, you are essentially declaring that it does >>>>> not exist. A zero-size species, parameter, rule, etc. would flatten to it >>>>> not being present. I suppose it is a bizarre way to delete something. You >>>>> can change its size variable to zero-size which effectively removes it. >>>>> This though likely creates validation rules as index computations may go >>>>> out-of-bounds, but this may not always be the case. >>>>> >>>>> So, my question is should we limit parameters used for size as >>>>> "non-negative" as we do now, or change it to "positive"? >>>>> >>>>> Chris >>>>> >>>>> >>>>> >>>>> ------------------------------------------------------------------------------ >>>>> _______________________________________________ >>>>> sbml-arrays mailing list >>>>> sbm...@li... >>>>> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >>>>> >>>> >>>> ------------------------------------------------------------------------------ >>>> _______________________________________________ >>>> sbml-arrays mailing list >>>> sbm...@li... >>>> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >>>> >>>> >>>> >>>> >>>> ------------------------------------------------------------------------------ >>>> >>>> _______________________________________________ >>>> sbml-arrays mailing list >>>> sbm...@li... >>>> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >>>> >>>> >>> >>> >>> ------------------------------------------------------------------------------ >>> >>> _______________________________________________ >>> sbml-arrays mailing list >>> sbm...@li... >>> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >>> >>> >> >> >> -- >> Bruce E. Shapiro, Ph.D. >> Department of Mathematics >> California State University, Northridge >> 18111 Nordhoff Street >> Northridge, CA 91330-8313 >> >> >> ------------------------------------------------------------------------------ >> >> _______________________________________________ >> sbml-arrays mailing list >> sbm...@li... >> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >> >> > > > ------------------------------------------------------------------------------ > > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > |
|
From: Chris J. M. <my...@ec...> - 2014-08-13 18:55:39
|
On Aug 13, 2014, at 12:36 PM, Lucian Smith <luc...@gm...> wrote: > Right, I am claiming that even if SBML arrays are officially static, they can be used in non-static contexts (such as parameter scan-like functions in tools, and in hierarchical models), and therefore should behave more like lists than arrays. > I don't think parameter scan is a reasonable argument to include it. Obviously, we would not allow a parameter scan to pick any value for the size as the size cannot be allowed to be negative. Also, it is tricky to right a model that is robust to changing sizes though it can be done in most cases again assuming non-negative values. Therefore, restricting the parameter scan to pick positive values seems completely reasonable, and indeed I think allowing zero will cause invalid models to be produced (see next). > When they are zero-length, they would, like empty lists, be equivalent to not including it in the model at all, except that references to it would be allowed. > You need to be very careful with references to a zero size object. When it gets flattened, the object will disappear and all references will not be invalid. So, if these objects do not also disappear, you end up with invalid SBML. In your earlier message, you said: > I would say that since it doesn't seem terribly difficult to support, has a clear meaning, and is potentially useful, that we allow it. Well, this is actually not true. They are not so easy to allow. They complicate both validation and flattening. In validation, when we do arrays bounds testing, we will need a special case to make sure their are actually any bounds at all. In flattening, zero size things will need to be "deleted" from the model, another special case. Finally, the last and to me potentially showstopper issue on this is that we are no longer going to be able to claim that when you flatten a valid model with arrays that you get a valid model without arrays. For the reason mentioned above, any references to a zero-size object will no longer point to a valid object after flattening. We could perhaps disallow references to zero-size objects as a new validation rule, but this just defeated the purpose of allowing zero-size objects since they cannot be referred to. As Bruce mentioned, zero-size lists (or sets) make a lot of sense because you can add to them. Indeed, when/if we create true set objects, I completely agree. However, zero-size static arrays do not seem particularly useful and do add significant complication. Therefore, I would prefer to disallow them unless a very compelling use case can be found. Chris > -Lucian > > > On Wed, Aug 13, 2014 at 11:18 AM, Bruce Shapiro <bru...@gm...> wrote: > I still don't understand how there would be an array parameter of zero length in a model. Are you saying that something might or might not exist in the model, and that zero length means it does not exist? > > > On Wed, Aug 13, 2014 at 11:09 AM, Lucian Smith <luc...@gm...> wrote: > There might be the case where the SBML model is under control of some other force, such as SED-ML or another simulation tool. A parameter scan, for example, does not require the parameter being scanned to be non-constant, but various different values are used for it over the course of several experiments, in each of which the parameter in question is constant. I can imagine a similar situation here, where someone is testing the behavior of a model under different circumstances, the simplest of which has a zero-sized array. > > Even within-SBML, one might have a hierarchical model where a submodel has a zero-sized array that becomes longer when imported and changed, or visa versa. > > I would say that since it doesn't seem terribly difficult to support, has a clear meaning, and is potentially useful, that we allow it. > > -Lucian > > > On Wed, Aug 13, 2014 at 11:00 AM, Chris J. Myers <my...@ec...> wrote: > I think in programming languages, there is often a difference between a zero-size array and a null pointer. You can use zero-size arrays as an initialization value, so you don't need to check for null all the time. However, this is with the assumption that you can later change the size of the array and add things to it. > > For arrays package with SBML, we made the decision that these would be static-size arrays. Therefore, a zero-size array will always be a zero-size array, and when this gets flattened to SBML core, the object is simply removed entirely. So, is such a behavior useful or simply create an unnecessary complication? > > Chris > > On Aug 13, 2014, at 11:06 AM, Bruce Shapiro <bru...@gm...> wrote: > >> Do any computer languages allow this? Isn't there already a symbol for the empty set for this this that one would normally use instead? Nil null bupkis >> >> Sent by an Android from another Galaxy. >> >> On Aug 13, 2014 9:41 AM, "Chris J. Myers" <my...@ec...> wrote: >> Hi, >> >> We were wondering if anyone sees a use for zero size arrays. When you declare something as zero-szie, you are essentially declaring that it does not exist. A zero-size species, parameter, rule, etc. would flatten to it not being present. I suppose it is a bizarre way to delete something. You can change its size variable to zero-size which effectively removes it. This though likely creates validation rules as index computations may go out-of-bounds, but this may not always be the case. >> >> So, my question is should we limit parameters used for size as "non-negative" as we do now, or change it to "positive"? >> >> Chris >> >> >> ------------------------------------------------------------------------------ >> _______________________________________________ >> sbml-arrays mailing list >> sbm...@li... >> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >> ------------------------------------------------------------------------------ >> _______________________________________________ >> sbml-arrays mailing list >> sbm...@li... >> https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > > ------------------------------------------------------------------------------ > > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > > > ------------------------------------------------------------------------------ > > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > > > > -- > Bruce E. Shapiro, Ph.D. > Department of Mathematics > California State University, Northridge > 18111 Nordhoff Street > Northridge, CA 91330-8313 > > ------------------------------------------------------------------------------ > > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > > ------------------------------------------------------------------------------ > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays |
|
From: Lucian S. <luc...@gm...> - 2014-08-13 18:36:27
|
Right, I am claiming that even if SBML arrays are officially static, they can be used in non-static contexts (such as parameter scan-like functions in tools, and in hierarchical models), and therefore should behave more like lists than arrays. When they are zero-length, they would, like empty lists, be equivalent to not including it in the model at all, except that references to it would be allowed. -Lucian On Wed, Aug 13, 2014 at 11:18 AM, Bruce Shapiro <bru...@gm...> wrote: > I still don't understand how there would be an array parameter of zero > length in a model. Are you saying that something might or might not exist > in the model, and that zero length means it does not exist? > > > On Wed, Aug 13, 2014 at 11:09 AM, Lucian Smith <luc...@gm...> > wrote: > >> There might be the case where the SBML model is under control of some >> other force, such as SED-ML or another simulation tool. A parameter scan, >> for example, does not require the parameter being scanned to be >> non-constant, but various different values are used for it over the course >> of several experiments, in each of which the parameter in question is >> constant. I can imagine a similar situation here, where someone is testing >> the behavior of a model under different circumstances, the simplest of >> which has a zero-sized array. >> >> Even within-SBML, one might have a hierarchical model where a submodel >> has a zero-sized array that becomes longer when imported and changed, or >> visa versa. >> >> I would say that since it doesn't seem terribly difficult to support, has >> a clear meaning, and is potentially useful, that we allow it. >> >> -Lucian >> >> >> On Wed, Aug 13, 2014 at 11:00 AM, Chris J. Myers <my...@ec...> >> wrote: >> >>> I think in programming languages, there is often a difference between a >>> zero-size array and a null pointer. You can use zero-size arrays as an >>> initialization value, so you don't need to check for null all the time. >>> However, this is with the assumption that you can later change the size of >>> the array and add things to it. >>> >>> For arrays package with SBML, we made the decision that these would be >>> static-size arrays. Therefore, a zero-size array will always be a >>> zero-size array, and when this gets flattened to SBML core, the object is >>> simply removed entirely. So, is such a behavior useful or simply create an >>> unnecessary complication? >>> >>> Chris >>> >>> On Aug 13, 2014, at 11:06 AM, Bruce Shapiro <bru...@gm...> >>> wrote: >>> >>> Do any computer languages allow this? Isn't there already a symbol for >>> the empty set for this this that one would normally use instead? Nil null >>> bupkis >>> >>> Sent by an Android from another Galaxy. >>> On Aug 13, 2014 9:41 AM, "Chris J. Myers" <my...@ec...> wrote: >>> >>>> Hi, >>>> >>>> We were wondering if anyone sees a use for zero size arrays. When you >>>> declare something as zero-szie, you are essentially declaring that it does >>>> not exist. A zero-size species, parameter, rule, etc. would flatten to it >>>> not being present. I suppose it is a bizarre way to delete something. You >>>> can change its size variable to zero-size which effectively removes it. >>>> This though likely creates validation rules as index computations may go >>>> out-of-bounds, but this may not always be the case. >>>> >>>> So, my question is should we limit parameters used for size as >>>> "non-negative" as we do now, or change it to "positive"? >>>> >>>> Chris >>>> >>>> >>>> >>>> ------------------------------------------------------------------------------ >>>> _______________________________________________ >>>> sbml-arrays mailing list >>>> sbm...@li... >>>> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >>>> >>> >>> ------------------------------------------------------------------------------ >>> _______________________________________________ >>> sbml-arrays mailing list >>> sbm...@li... >>> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >>> >>> >>> >>> >>> ------------------------------------------------------------------------------ >>> >>> _______________________________________________ >>> sbml-arrays mailing list >>> sbm...@li... >>> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >>> >>> >> >> >> ------------------------------------------------------------------------------ >> >> _______________________________________________ >> sbml-arrays mailing list >> sbm...@li... >> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >> >> > > > -- > Bruce E. Shapiro, Ph.D. > Department of Mathematics > California State University, Northridge > 18111 Nordhoff Street > Northridge, CA 91330-8313 > > > ------------------------------------------------------------------------------ > > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > |
|
From: Bruce S. <bru...@gm...> - 2014-08-13 18:19:23
|
I still don't understand how there would be an array parameter of zero length in a model. Are you saying that something might or might not exist in the model, and that zero length means it does not exist? On Wed, Aug 13, 2014 at 11:09 AM, Lucian Smith <luc...@gm...> wrote: > There might be the case where the SBML model is under control of some > other force, such as SED-ML or another simulation tool. A parameter scan, > for example, does not require the parameter being scanned to be > non-constant, but various different values are used for it over the course > of several experiments, in each of which the parameter in question is > constant. I can imagine a similar situation here, where someone is testing > the behavior of a model under different circumstances, the simplest of > which has a zero-sized array. > > Even within-SBML, one might have a hierarchical model where a submodel has > a zero-sized array that becomes longer when imported and changed, or visa > versa. > > I would say that since it doesn't seem terribly difficult to support, has > a clear meaning, and is potentially useful, that we allow it. > > -Lucian > > > On Wed, Aug 13, 2014 at 11:00 AM, Chris J. Myers <my...@ec...> > wrote: > >> I think in programming languages, there is often a difference between a >> zero-size array and a null pointer. You can use zero-size arrays as an >> initialization value, so you don't need to check for null all the time. >> However, this is with the assumption that you can later change the size of >> the array and add things to it. >> >> For arrays package with SBML, we made the decision that these would be >> static-size arrays. Therefore, a zero-size array will always be a >> zero-size array, and when this gets flattened to SBML core, the object is >> simply removed entirely. So, is such a behavior useful or simply create an >> unnecessary complication? >> >> Chris >> >> On Aug 13, 2014, at 11:06 AM, Bruce Shapiro <bru...@gm...> >> wrote: >> >> Do any computer languages allow this? Isn't there already a symbol for >> the empty set for this this that one would normally use instead? Nil null >> bupkis >> >> Sent by an Android from another Galaxy. >> On Aug 13, 2014 9:41 AM, "Chris J. Myers" <my...@ec...> wrote: >> >>> Hi, >>> >>> We were wondering if anyone sees a use for zero size arrays. When you >>> declare something as zero-szie, you are essentially declaring that it does >>> not exist. A zero-size species, parameter, rule, etc. would flatten to it >>> not being present. I suppose it is a bizarre way to delete something. You >>> can change its size variable to zero-size which effectively removes it. >>> This though likely creates validation rules as index computations may go >>> out-of-bounds, but this may not always be the case. >>> >>> So, my question is should we limit parameters used for size as >>> "non-negative" as we do now, or change it to "positive"? >>> >>> Chris >>> >>> >>> >>> ------------------------------------------------------------------------------ >>> _______________________________________________ >>> sbml-arrays mailing list >>> sbm...@li... >>> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >>> >> >> ------------------------------------------------------------------------------ >> _______________________________________________ >> sbml-arrays mailing list >> sbm...@li... >> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >> >> >> >> >> ------------------------------------------------------------------------------ >> >> _______________________________________________ >> sbml-arrays mailing list >> sbm...@li... >> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >> >> > > > ------------------------------------------------------------------------------ > > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > -- Bruce E. Shapiro, Ph.D. Department of Mathematics California State University, Northridge 18111 Nordhoff Street Northridge, CA 91330-8313 |
|
From: Bruce S. <bru...@gm...> - 2014-08-13 18:16:24
|
I guess my question was more whether any programming languages actually allowed zero-length arrays. I can't think of any reason why this would be useful. I can think of zero length lists, but lists are variable length structures so this makes sense. The whole point of arrays (I'm not talking about fake arrays like lists with indices that can be dynamically changed in a programming language but real arrays) is usually that they save space (compare numpy arrays vs. python lists (which really aren't arrays). If the question is do we allow zero length lists, the answer is yes, because lists are inherently dynamic and are allowed to grow. If there are no options for a dynamic structure in addition to the static array then proceed to the next paragraph. If the question is do we allow zero length arrays, the answer is no, because arrays are inherently static and fixed length and a zero length array is an added complication (IMHO). On Wed, Aug 13, 2014 at 11:00 AM, Chris J. Myers <my...@ec...> wrote: > I think in programming languages, there is often a difference between a > zero-size array and a null pointer. You can use zero-size arrays as an > initialization value, so you don't need to check for null all the time. > However, this is with the assumption that you can later change the size of > the array and add things to it. > > For arrays package with SBML, we made the decision that these would be > static-size arrays. Therefore, a zero-size array will always be a > zero-size array, and when this gets flattened to SBML core, the object is > simply removed entirely. So, is such a behavior useful or simply create an > unnecessary complication? > > Chris > > On Aug 13, 2014, at 11:06 AM, Bruce Shapiro <bru...@gm...> > wrote: > > Do any computer languages allow this? Isn't there already a symbol for > the empty set for this this that one would normally use instead? Nil null > bupkis > > Sent by an Android from another Galaxy. > On Aug 13, 2014 9:41 AM, "Chris J. Myers" <my...@ec...> wrote: > >> Hi, >> >> We were wondering if anyone sees a use for zero size arrays. When you >> declare something as zero-szie, you are essentially declaring that it does >> not exist. A zero-size species, parameter, rule, etc. would flatten to it >> not being present. I suppose it is a bizarre way to delete something. You >> can change its size variable to zero-size which effectively removes it. >> This though likely creates validation rules as index computations may go >> out-of-bounds, but this may not always be the case. >> >> So, my question is should we limit parameters used for size as >> "non-negative" as we do now, or change it to "positive"? >> >> Chris >> >> >> >> ------------------------------------------------------------------------------ >> _______________________________________________ >> sbml-arrays mailing list >> sbm...@li... >> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >> > > ------------------------------------------------------------------------------ > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > > > > ------------------------------------------------------------------------------ > > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > -- Bruce E. Shapiro, Ph.D. Department of Mathematics California State University, Northridge 18111 Nordhoff Street Northridge, CA 91330-8313 |
|
From: Lucian S. <luc...@gm...> - 2014-08-13 18:09:53
|
There might be the case where the SBML model is under control of some other force, such as SED-ML or another simulation tool. A parameter scan, for example, does not require the parameter being scanned to be non-constant, but various different values are used for it over the course of several experiments, in each of which the parameter in question is constant. I can imagine a similar situation here, where someone is testing the behavior of a model under different circumstances, the simplest of which has a zero-sized array. Even within-SBML, one might have a hierarchical model where a submodel has a zero-sized array that becomes longer when imported and changed, or visa versa. I would say that since it doesn't seem terribly difficult to support, has a clear meaning, and is potentially useful, that we allow it. -Lucian On Wed, Aug 13, 2014 at 11:00 AM, Chris J. Myers <my...@ec...> wrote: > I think in programming languages, there is often a difference between a > zero-size array and a null pointer. You can use zero-size arrays as an > initialization value, so you don't need to check for null all the time. > However, this is with the assumption that you can later change the size of > the array and add things to it. > > For arrays package with SBML, we made the decision that these would be > static-size arrays. Therefore, a zero-size array will always be a > zero-size array, and when this gets flattened to SBML core, the object is > simply removed entirely. So, is such a behavior useful or simply create an > unnecessary complication? > > Chris > > On Aug 13, 2014, at 11:06 AM, Bruce Shapiro <bru...@gm...> > wrote: > > Do any computer languages allow this? Isn't there already a symbol for > the empty set for this this that one would normally use instead? Nil null > bupkis > > Sent by an Android from another Galaxy. > On Aug 13, 2014 9:41 AM, "Chris J. Myers" <my...@ec...> wrote: > >> Hi, >> >> We were wondering if anyone sees a use for zero size arrays. When you >> declare something as zero-szie, you are essentially declaring that it does >> not exist. A zero-size species, parameter, rule, etc. would flatten to it >> not being present. I suppose it is a bizarre way to delete something. You >> can change its size variable to zero-size which effectively removes it. >> This though likely creates validation rules as index computations may go >> out-of-bounds, but this may not always be the case. >> >> So, my question is should we limit parameters used for size as >> "non-negative" as we do now, or change it to "positive"? >> >> Chris >> >> >> >> ------------------------------------------------------------------------------ >> _______________________________________________ >> sbml-arrays mailing list >> sbm...@li... >> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >> > > ------------------------------------------------------------------------------ > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > > > > ------------------------------------------------------------------------------ > > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > |
|
From: Chris J. M. <my...@ec...> - 2014-08-13 18:00:32
|
I think in programming languages, there is often a difference between a zero-size array and a null pointer. You can use zero-size arrays as an initialization value, so you don't need to check for null all the time. However, this is with the assumption that you can later change the size of the array and add things to it. For arrays package with SBML, we made the decision that these would be static-size arrays. Therefore, a zero-size array will always be a zero-size array, and when this gets flattened to SBML core, the object is simply removed entirely. So, is such a behavior useful or simply create an unnecessary complication? Chris On Aug 13, 2014, at 11:06 AM, Bruce Shapiro <bru...@gm...> wrote: > Do any computer languages allow this? Isn't there already a symbol for the empty set for this this that one would normally use instead? Nil null bupkis > > Sent by an Android from another Galaxy. > > On Aug 13, 2014 9:41 AM, "Chris J. Myers" <my...@ec...> wrote: > Hi, > > We were wondering if anyone sees a use for zero size arrays. When you declare something as zero-szie, you are essentially declaring that it does not exist. A zero-size species, parameter, rule, etc. would flatten to it not being present. I suppose it is a bizarre way to delete something. You can change its size variable to zero-size which effectively removes it. This though likely creates validation rules as index computations may go out-of-bounds, but this may not always be the case. > > So, my question is should we limit parameters used for size as "non-negative" as we do now, or change it to "positive"? > > Chris > > > ------------------------------------------------------------------------------ > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > ------------------------------------------------------------------------------ > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays |
|
From: Bruce S. <bru...@gm...> - 2014-08-13 17:07:07
|
Do any computer languages allow this? Isn't there already a symbol for the empty set for this this that one would normally use instead? Nil null bupkis Sent by an Android from another Galaxy. On Aug 13, 2014 9:41 AM, "Chris J. Myers" <my...@ec...> wrote: > Hi, > > We were wondering if anyone sees a use for zero size arrays. When you > declare something as zero-szie, you are essentially declaring that it does > not exist. A zero-size species, parameter, rule, etc. would flatten to it > not being present. I suppose it is a bizarre way to delete something. You > can change its size variable to zero-size which effectively removes it. > This though likely creates validation rules as index computations may go > out-of-bounds, but this may not always be the case. > > So, my question is should we limit parameters used for size as > "non-negative" as we do now, or change it to "positive"? > > Chris > > > > ------------------------------------------------------------------------------ > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > |
|
From: Chris J. M. <my...@ec...> - 2014-08-13 16:41:29
|
Hi, We were wondering if anyone sees a use for zero size arrays. When you declare something as zero-szie, you are essentially declaring that it does not exist. A zero-size species, parameter, rule, etc. would flatten to it not being present. I suppose it is a bizarre way to delete something. You can change its size variable to zero-size which effectively removes it. This though likely creates validation rules as index computations may go out-of-bounds, but this may not always be the case. So, my question is should we limit parameters used for size as "non-negative" as we do now, or change it to "positive"? Chris |
|
From: Chris J. M. <my...@ec...> - 2014-08-09 15:51:43
|
Ok, this is embarrassing. But, after writing this email, I realized another reason why we are stuck with the second interpretation. The problem is that the species references ids are globally scoped, so in the former interpretation below, we would end up with duplicate identifiers "a, b, and c" which would be invalid SBML. This is why we have to make the id's unique which is where the implicit array dimension come into play. It is not pretty. In fact, it strongly encourages me to suggest a return to stoichiometry math which was frankly much cleaner as it is locally scoped and could make use of local parameters (a very useful thing). Chris On Aug 9, 2014, at 9:42 AM, Chris J. Myers <my...@ec...> wrote: > Hi Bruce, > > Your example should work with the arrays package as follows: > > Parameters > n:=100 > m:=3 > o:=4 > > Species > R[n][o] > L[n] > > Reactions > ID: r[n][m] with dimension ids d0 and d1 > Reactants: > R[d0][d1] > L[d0] > Products: > R[d0][d1+1] > > An important thing to note is that the species references themselves do not have dimensions. However, let's consider the case where there are species reference ids. > > Reactions > ID: r[n][m] with dimension ids d0 and d1 > Reactants: > a: R[d0][d1] > b: L[d0] > Products: > c: R[d0][d1+1] > > Now, when this gets flattened, do we get this: > > a R_0_0 + b L_0 -> c R_0_1 > a R_0_1 + b L_0 -> c R_0_2 > a R_0_2 + b L_0 -> c R_0_3 > a R_1_0 + b L_1 -> c R_1_1 > a R_1_1 + b L_1 -> c R_1_2 > a R_1_2 + b L_1 -> c R_1_3 > etc. > > OR > > a_0_0 R_0_0 + b_0_0 L_0 -> c_0_0 R_0_1 > a_0_1 R_0_1 + b_0_1 L_0 -> c_0_1 R_0_2 > a_0_2 R_0_2 + b_0_2 L_0 -> c_0_2 R_0_3 > a_1_0 R_1_0 + b_1_0 L_1 -> c_1_0 R_1_1 > a_1_1 R_1_1 + b_1_1 L_1 -> c_1_1 R_1_2 > a_1_2 R_1_2 + b_1_2 L_1 -> c_1_2 R_1_3 > etc. > > My original thought was that we get the later one, so we could potentially specify different stoichiometry for each in rules outside, but this implies implicit dimensions for the species reference ids. Now, I'm leaning towards the former interpretation as this would not have implicit dimensions, a cleaner flatten, and a more clear interpretation from a user's perspective. The only downside is the stoichiometry will need to be the same for all the reactions, but perhaps this is expected since when using arrays you would expect there to be regularity. > > Thoughts? > > Chris > > On Aug 5, 2014, at 8:48 PM, Bruce Shapiro <bru...@gm...> wrote: > >> (Thought I'd come back from the dead and give you my 2cents worth) >> >> A concrete example would help. >> >> Perhaps a receptor with 3 binding sites can be treated as an array of length 4, can bind to ligand L[i] in compartment L[i] >> , where you only care about how many ligands are bound, and not which site they are bound to: >> >> R has two dimensions, and L has only one dimension? >> >> R[i, 0] + L[i] -> R[i, 1] >> R[i, 1] + L[i] -> R[i, 2] >> R[i, 2] + L[i] -> R[i, 3] >> >> If there are 100 compartments (like in the spec example) R is 100 x 4, L is 100 x 1 >> >> >> BES >> >> >> >> >> >> On Tue, Aug 5, 2014 at 5:38 PM, Chris J. Myers <my...@ec...> wrote: >> Yes this may be possible like in this case where a single reaction acts on arrays of reactants and products. >> >> Seems useful. >> >> Chris >> >> Sent from my iPhone >> >> On Aug 5, 2014, at 1:50 AM, Sarah Keating <ske...@ca...> wrote: >> >> > Hi Chris >> > >> > Could you clarify for me ... >> > >> > when you talk about this >> > >> >> >> >> Reaction R >> >> Reactant a[n] A[d0], b[n] B[d0] >> >> Products c[n] C[d0] >> >> >> >> So, this is one reaction with 4 reactants and 2 products >> > >> > >> > are you envisaging allowing a situation where the dimensions of a >> > reaction do not match the dimensions of the species referenced as >> > reactants/products/modifiers ?? >> > >> > Sarah >> > >> > ------------------------------------------------------------------------------ >> > Infragistics Professional >> > Build stunning WinForms apps today! >> > Reboot your WinForms applications with our WinForms controls. >> > Build a bridge from your legacy apps to the future. >> > http://pubads.g.doubleclick.net/gampad/clk?id=153845071&iu=/4140/ostg.clktrk >> > _______________________________________________ >> > sbml-arrays mailing list >> > sbm...@li... >> > https://lists.sourceforge.net/lists/listinfo/sbml-arrays >> >> ------------------------------------------------------------------------------ >> Infragistics Professional >> Build stunning WinForms apps today! >> Reboot your WinForms applications with our WinForms controls. >> Build a bridge from your legacy apps to the future. >> http://pubads.g.doubleclick.net/gampad/clk?id=153845071&iu=/4140/ostg.clktrk >> _______________________________________________ >> sbml-arrays mailing list >> sbm...@li... >> https://lists.sourceforge.net/lists/listinfo/sbml-arrays >> >> >> >> -- >> Bruce E. Shapiro, Ph.D. >> Department of Mathematics >> California State University, Northridge >> 18111 Nordhoff Street >> Northridge, CA 91330-8313 >> ------------------------------------------------------------------------------ >> Infragistics Professional >> Build stunning WinForms apps today! >> Reboot your WinForms applications with our WinForms controls. >> Build a bridge from your legacy apps to the future. >> http://pubads.g.doubleclick.net/gampad/clk?id=153845071&iu=/4140/ostg.clktrk_______________________________________________ >> sbml-arrays mailing list >> sbm...@li... >> https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > ------------------------------------------------------------------------------ > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays |
|
From: Chris J. M. <my...@ec...> - 2014-08-09 15:46:53
|
Your interpretation is completely correct assuming the species references themselves are given dimensions and an index consistent with your interpretation. Namely, n = 2 Reaction R Reactants a[n] S1[d0] b[n] S2[d0] Products c[n] S3[d0] where d0 is the dimension id for each species reference. This flattens to: a_0 S1_0 + b_0 S2_0 + a_1 S1_1 + b_1 S2_1 => c_0 S3_0 + c_1 S3_1 Chris On Aug 8, 2014, at 2:31 AM, Sarah Keating <ske...@ca...> wrote: > So I am still trying to understand why the stoichiometry would match the > dimensions of the reaction and not the dimensions of the species ! > > In the example Chris uses [Bruce has gone way further :-) ] > > One Reaction with 4 reactants and 2 products specified as > > n = 2 > Reaction R > reactants: S1[n], S2[n] > products: S3[n] > > I assume this would expand to > > R: S1_0 + S1_1 + S2_0 + S2_1 => S3_0 + S3_1 > > If my assumption is correct (and this is not certain!) then surely > each species could have it's own stoichiometry. > > Sarah > > > ------------------------------------------------------------------------------ > Want fast and easy access to all the code in your enterprise? Index and > search up to 200,000 lines of code with a free copy of Black Duck > Code Sight - the same software that powers the world's largest code > search on Ohloh, the Black Duck Open Hub! Try it now. > http://p.sf.net/sfu/bds > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays |
|
From: Chris J. M. <my...@ec...> - 2014-08-09 15:42:24
|
Hi Bruce, Your example should work with the arrays package as follows: Parameters n:=100 m:=3 o:=4 Species R[n][o] L[n] Reactions ID: r[n][m] with dimension ids d0 and d1 Reactants: R[d0][d1] L[d0] Products: R[d0][d1+1] An important thing to note is that the species references themselves do not have dimensions. However, let's consider the case where there are species reference ids. Reactions ID: r[n][m] with dimension ids d0 and d1 Reactants: a: R[d0][d1] b: L[d0] Products: c: R[d0][d1+1] Now, when this gets flattened, do we get this: a R_0_0 + b L_0 -> c R_0_1 a R_0_1 + b L_0 -> c R_0_2 a R_0_2 + b L_0 -> c R_0_3 a R_1_0 + b L_1 -> c R_1_1 a R_1_1 + b L_1 -> c R_1_2 a R_1_2 + b L_1 -> c R_1_3 etc. OR a_0_0 R_0_0 + b_0_0 L_0 -> c_0_0 R_0_1 a_0_1 R_0_1 + b_0_1 L_0 -> c_0_1 R_0_2 a_0_2 R_0_2 + b_0_2 L_0 -> c_0_2 R_0_3 a_1_0 R_1_0 + b_1_0 L_1 -> c_1_0 R_1_1 a_1_1 R_1_1 + b_1_1 L_1 -> c_1_1 R_1_2 a_1_2 R_1_2 + b_1_2 L_1 -> c_1_2 R_1_3 etc. My original thought was that we get the later one, so we could potentially specify different stoichiometry for each in rules outside, but this implies implicit dimensions for the species reference ids. Now, I'm leaning towards the former interpretation as this would not have implicit dimensions, a cleaner flatten, and a more clear interpretation from a user's perspective. The only downside is the stoichiometry will need to be the same for all the reactions, but perhaps this is expected since when using arrays you would expect there to be regularity. Thoughts? Chris On Aug 5, 2014, at 8:48 PM, Bruce Shapiro <bru...@gm...> wrote: > (Thought I'd come back from the dead and give you my 2cents worth) > > A concrete example would help. > > Perhaps a receptor with 3 binding sites can be treated as an array of length 4, can bind to ligand L[i] in compartment L[i] > , where you only care about how many ligands are bound, and not which site they are bound to: > > R has two dimensions, and L has only one dimension? > > R[i, 0] + L[i] -> R[i, 1] > R[i, 1] + L[i] -> R[i, 2] > R[i, 2] + L[i] -> R[i, 3] > > If there are 100 compartments (like in the spec example) R is 100 x 4, L is 100 x 1 > > > BES > > > > > > On Tue, Aug 5, 2014 at 5:38 PM, Chris J. Myers <my...@ec...> wrote: > Yes this may be possible like in this case where a single reaction acts on arrays of reactants and products. > > Seems useful. > > Chris > > Sent from my iPhone > > On Aug 5, 2014, at 1:50 AM, Sarah Keating <ske...@ca...> wrote: > > > Hi Chris > > > > Could you clarify for me ... > > > > when you talk about this > > > >> > >> Reaction R > >> Reactant a[n] A[d0], b[n] B[d0] > >> Products c[n] C[d0] > >> > >> So, this is one reaction with 4 reactants and 2 products > > > > > > are you envisaging allowing a situation where the dimensions of a > > reaction do not match the dimensions of the species referenced as > > reactants/products/modifiers ?? > > > > Sarah > > > > ------------------------------------------------------------------------------ > > Infragistics Professional > > Build stunning WinForms apps today! > > Reboot your WinForms applications with our WinForms controls. > > Build a bridge from your legacy apps to the future. > > http://pubads.g.doubleclick.net/gampad/clk?id=153845071&iu=/4140/ostg.clktrk > > _______________________________________________ > > sbml-arrays mailing list > > sbm...@li... > > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > ------------------------------------------------------------------------------ > Infragistics Professional > Build stunning WinForms apps today! > Reboot your WinForms applications with our WinForms controls. > Build a bridge from your legacy apps to the future. > http://pubads.g.doubleclick.net/gampad/clk?id=153845071&iu=/4140/ostg.clktrk > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > > > -- > Bruce E. Shapiro, Ph.D. > Department of Mathematics > California State University, Northridge > 18111 Nordhoff Street > Northridge, CA 91330-8313 > ------------------------------------------------------------------------------ > Infragistics Professional > Build stunning WinForms apps today! > Reboot your WinForms applications with our WinForms controls. > Build a bridge from your legacy apps to the future. > http://pubads.g.doubleclick.net/gampad/clk?id=153845071&iu=/4140/ostg.clktrk_______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays |
|
From: Sarah K. <ske...@ca...> - 2014-08-08 08:31:02
|
So I am still trying to understand why the stoichiometry would match the dimensions of the reaction and not the dimensions of the species ! In the example Chris uses [Bruce has gone way further :-) ] One Reaction with 4 reactants and 2 products specified as n = 2 Reaction R reactants: S1[n], S2[n] products: S3[n] I assume this would expand to R: S1_0 + S1_1 + S2_0 + S2_1 => S3_0 + S3_1 If my assumption is correct (and this is not certain!) then surely each species could have it's own stoichiometry. Sarah |
|
From: Bruce S. <bru...@gm...> - 2014-08-06 02:49:24
|
(Thought I'd come back from the dead and give you my 2cents worth) A concrete example would help. Perhaps a receptor with 3 binding sites can be treated as an array of length 4, can bind to ligand L[i] in compartment L[i] , where you only care about how many ligands are bound, and not which site they are bound to: R has two dimensions, and L has only one dimension? R[i, 0] + L[i] -> R[i, 1] R[i, 1] + L[i] -> R[i, 2] R[i, 2] + L[i] -> R[i, 3] If there are 100 compartments (like in the spec example) R is 100 x 4, L is 100 x 1 BES On Tue, Aug 5, 2014 at 5:38 PM, Chris J. Myers <my...@ec...> wrote: > Yes this may be possible like in this case where a single reaction acts on > arrays of reactants and products. > > Seems useful. > > Chris > > Sent from my iPhone > > On Aug 5, 2014, at 1:50 AM, Sarah Keating <ske...@ca...> wrote: > > > Hi Chris > > > > Could you clarify for me ... > > > > when you talk about this > > > >> > >> Reaction R > >> Reactant a[n] A[d0], b[n] B[d0] > >> Products c[n] C[d0] > >> > >> So, this is one reaction with 4 reactants and 2 products > > > > > > are you envisaging allowing a situation where the dimensions of a > > reaction do not match the dimensions of the species referenced as > > reactants/products/modifiers ?? > > > > Sarah > > > > > ------------------------------------------------------------------------------ > > Infragistics Professional > > Build stunning WinForms apps today! > > Reboot your WinForms applications with our WinForms controls. > > Build a bridge from your legacy apps to the future. > > > http://pubads.g.doubleclick.net/gampad/clk?id=153845071&iu=/4140/ostg.clktrk > > _______________________________________________ > > sbml-arrays mailing list > > sbm...@li... > > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > > > ------------------------------------------------------------------------------ > Infragistics Professional > Build stunning WinForms apps today! > Reboot your WinForms applications with our WinForms controls. > Build a bridge from your legacy apps to the future. > > http://pubads.g.doubleclick.net/gampad/clk?id=153845071&iu=/4140/ostg.clktrk > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays > -- Bruce E. Shapiro, Ph.D. Department of Mathematics California State University, Northridge 18111 Nordhoff Street Northridge, CA 91330-8313 |
|
From: Chris J. M. <my...@ec...> - 2014-08-06 00:42:47
|
Yes this may be possible like in this case where a single reaction acts on arrays of reactants and products. Seems useful. Chris Sent from my iPhone On Aug 5, 2014, at 1:50 AM, Sarah Keating <ske...@ca...> wrote: > Hi Chris > > Could you clarify for me ... > > when you talk about this > >> >> Reaction R >> Reactant a[n] A[d0], b[n] B[d0] >> Products c[n] C[d0] >> >> So, this is one reaction with 4 reactants and 2 products > > > are you envisaging allowing a situation where the dimensions of a > reaction do not match the dimensions of the species referenced as > reactants/products/modifiers ?? > > Sarah > > ------------------------------------------------------------------------------ > Infragistics Professional > Build stunning WinForms apps today! > Reboot your WinForms applications with our WinForms controls. > Build a bridge from your legacy apps to the future. > http://pubads.g.doubleclick.net/gampad/clk?id=153845071&iu=/4140/ostg.clktrk > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays |
|
From: Sarah K. <ske...@ca...> - 2014-08-05 08:50:31
|
Hi Chris Could you clarify for me ... when you talk about this > > Reaction R > Reactant a[n] A[d0], b[n] B[d0] > Products c[n] C[d0] > > So, this is one reaction with 4 reactants and 2 products are you envisaging allowing a situation where the dimensions of a reaction do not match the dimensions of the species referenced as reactants/products/modifiers ?? Sarah |
|
From: Chris J. M. <my...@ec...> - 2014-08-02 12:23:27
|
I agree with this as it will make validation and flattening easier. The one case where this seems unavoidable though is species reference ids which must infer a dimension from the reaction they are part of. This seems it will need to be special cased. Chris Sent from my iPhone On Aug 2, 2014, at 5:05 AM, Sarah Keating <ske...@ca...> wrote: > Hi Guys > >> 1) Should all assignments to arrays have explicit dimensions or do we allow dimensions to be inferred from the math in the assignment? > > I have to say I am very against having anything implicit :-( > > With SBML Level 3 we removed all defaults because these had been an > issue with users. It was decided that since SBML is for machines to read > it does not matter if it has loads of additional text that maybe repeats > information. > > I would argue that any assignment to an array has to also declare > dimensions explicitly. > > Sarah > > ------------------------------------------------------------------------------ > Want fast and easy access to all the code in your enterprise? Index and > search up to 200,000 lines of code with a free copy of Black Duck > Code Sight - the same software that powers the world's largest code > search on Ohloh, the Black Duck Open Hub! Try it now. > http://p.sf.net/sfu/bds > _______________________________________________ > sbml-arrays mailing list > sbm...@li... > https://lists.sourceforge.net/lists/listinfo/sbml-arrays |
|
From: Sarah K. <ske...@ca...> - 2014-08-02 11:04:56
|
Hi Guys > 1) Should all assignments to arrays have explicit dimensions or do we allow dimensions to be inferred from the math in the assignment? I have to say I am very against having anything implicit :-( With SBML Level 3 we removed all defaults because these had been an issue with users. It was decided that since SBML is for machines to read it does not matter if it has loads of additional text that maybe repeats information. I would argue that any assignment to an array has to also declare dimensions explicitly. Sarah |
|
From: Chris J. M. <my...@ec...> - 2014-07-29 16:01:19
|
Let me see if I understand how this rule would apply to the three scenarios below.
1) An assignment rule that uses has math which evaluates to an array such as when using a vector, must have dimensions to match. So, X={1,2,3} is not legal unless this assignment rule has a dimension of size 3.
3) For events, it is clear that if an event has a dimension than its trigger, delay, and priority must also match in size. If the event assignments do not have dimensions, then they simply get copied when flattening the event. However, if they have a dimension, then they get flattened first, then the events are flattened. I think this works.
2) The tricky case is reactions. A reaction with dimensions will imply that its speciesReferences and modifierSpeciesReferences are also to have the same dimensions. So,
Parameter n:=2
Reaction R[n] with dimension id d0
A[d0] + B[d0] --> C[d0]
Expands to:
R_0 : A_0 + B_0 --> C_0
R_1 : A_1 + B_1 --> C_1
Now, what if the speciesReferences have id's. I suppose they will also need to be expanded. This is going to be a bit odd as any assignments that involve these speciesReference ids is going to have an "implied" dimension derived from the reaction dimension. I'm not sure how to get around this "implied" dimension. My original thought was to require the dimension to be specified in this case. As follows:
Reaction R[n]
Reactants a[n] A[d0], b[n] B[d0]
Products c[n] C[d0]
where a, b, and c are the species reference ids. But this has a problem, in how do you specify a single reaction with an array of reactants and products?
Reaction R
Reactant a[n] A[d0], b[n] B[d0]
Products c[n] C[d0]
So, this is one reaction with 4 reactants and 2 products while the one earlier is 2 reactions each with 2 reactants and 1 product. It gets even worse if you want to specify 2 reactions with arrayed reactants and products.
So, I think that the only solution is that the speciesReference id's end up with an implied dimension from the reaction. Does this make sense?
Chris
On Jul 28, 2014, at 10:39 PM, Lucian Smith <luc...@gm...> wrote:
> It definitely seems to me that in general, if an element has a parent with some dimensionality, it should, by default, have that same dimensionality. That would go for SpeciesReferences, EventAssignments, Priorities, KineticLaws, etc. I assume that it's going to be easiest for it to just inherit the details from the parent instead of having to explicitly reproduce it for anything you want to reference.
>
> If, *within* that object, you need additional dimensionality (as you might with the EventAssignment/Event pair), I agree that that should add a new dimension to that object, so if its parent already had a dimension, that would give it a new dimension (and in your example, you'd have 25 effective EventAssignments).
>
> I don't think there's any parent/child object in SBML as it currently stands that we would not want to handle this way. Could that be a reasonable general rule?
>
> -Lucian
>
>
> On Mon, Jul 28, 2014 at 6:40 PM, Chris J. Myers <my...@ec...> wrote:
> Thanks to Leandro Watanabe and the help of his mentors, there is a prototype of the arrays package in JSBML. This includes the dimension and index data structures, additional mathML constructs (selector and vector), validation procedures, and a procedure to flatten to a core model. All of these features are still undergoing extensive testing and may still have some gaps in their implementation.
>
> The implementation of the flattening procedure has highlighted a few corner cases that we would appreciate some input on either on the mailing list or at COMBINE next month.
>
> 1) Should all assignments to arrays have explicit dimensions or do we allow dimensions to be inferred from the math in the assignment?
>
> As a simple case, assume you have the following:
>
> Parameter
> n := 3
> X[n] <--- array of size n
>
> Assignment Rule
> X = { 1, 2, 3 }
>
> If we allow implicit dimensions, then the flatten procedure than needs to determine the size of the vector, make sure it matches the size of X, then convert this to:
>
> Assignment Rules
> X_0 := 1
> X_1 := 2
> X_2 := 3
>
> This is made much easier though if we can assume that the assignment rule in the original model has these dimensions provided explicitly. Namely, the assignment rule is described as follows:
>
> Assignment Rule
> Dimension d0 with size n
> Index d0
> X = { 1, 2, 3 }
>
> Now, flattening is very mechanical and straightforward.
>
> 2) Is a dimension ever make sense for a speciesReference without an id? Should it be required to be the same as the dimension for the reaction?
>
> Assume you have the following:
>
> Parameter
> n := 2
>
> Species
> S[n]
>
> Reaction
> R[n]
> a[n] S[d0] --> ()
>
> This gets flattened to:
>
> Species
> S_0
> S_1
>
> Reaction
> R_0: a_0 S_0 --> ()
> R_1: a_1 S_1 --> ()
>
> Basically, the flatten procedure copies all the speciesReferences as it is expanding the reactions. However, when there is a speciesReference id, it must also expand its id. It seems to me that it would never make sense to have an id with a dimension other than the reaction dimension. Also, if the reaction has dimensions, then the speciesReference must have them as well. That is unless we decide we like implicit dimensions.
>
> 3) Finally, how do you interpret events when there are dimensions on both the event and the event assignments. For example, if you have an event of size 5 with an event assignment of size 5. Is this 5 events each with one event assignment? Or 5 events each with 5 event assignments? I prefer the later interpretation. This means you expand the event assignments first, then the events. For example:
>
> Parameter
> n := 5
>
> Species
> X[n]
>
> Event
> E[n] with dimension id d0
> Trigger { true, true, true, true, true}
> Delay { 1, 2, 3, 4, 5 }
> Event Assignments
> Dimension ed0 of size n
> X[d0] := 2 * d0 * ed0
>
> Expands to:
>
> E_0
> Trigger true
> Delay 1
> Event Assignments
> X_0 := 0
> X_1 := 0
> X_2 := 0
> X_3 := 0
> X_4 := 0
>
> E_1
> Trigger true
> Delay 2
> Event Assignments
> X_0 := 0
> X_1 := 2
> X_2 := 4
> X_3 := 6
> X_4 := 8
> etc.
>
> Your feedback on all three of these issues is greatly appreciated.
>
> Cheers,
>
> Chris
>
>
>
>
>
>
>
>
> ------------------------------------------------------------------------------
> Infragistics Professional
> Build stunning WinForms apps today!
> Reboot your WinForms applications with our WinForms controls.
> Build a bridge from your legacy apps to the future.
> http://pubads.g.doubleclick.net/gampad/clk?id=153845071&iu=/4140/ostg.clktrk
> _______________________________________________
> sbml-arrays mailing list
> sbm...@li...
> https://lists.sourceforge.net/lists/listinfo/sbml-arrays
>
> ------------------------------------------------------------------------------
> Infragistics Professional
> Build stunning WinForms apps today!
> Reboot your WinForms applications with our WinForms controls.
> Build a bridge from your legacy apps to the future.
> http://pubads.g.doubleclick.net/gampad/clk?id=153845071&iu=/4140/ostg.clktrk_______________________________________________
> sbml-arrays mailing list
> sbm...@li...
> https://lists.sourceforge.net/lists/listinfo/sbml-arrays
|
|
From: Lucian S. <luc...@gm...> - 2014-07-29 04:39:30
|
It definitely seems to me that in general, if an element has a parent with
some dimensionality, it should, by default, have that same dimensionality.
That would go for SpeciesReferences, EventAssignments, Priorities,
KineticLaws, etc. I assume that it's going to be easiest for it to just
inherit the details from the parent instead of having to explicitly
reproduce it for anything you want to reference.
If, *within* that object, you need additional dimensionality (as you might
with the EventAssignment/Event pair), I agree that that should add a new
dimension to that object, so if its parent already had a dimension, that
would give it a new dimension (and in your example, you'd have 25 effective
EventAssignments).
I don't think there's any parent/child object in SBML as it currently
stands that we would not want to handle this way. Could that be a
reasonable general rule?
-Lucian
On Mon, Jul 28, 2014 at 6:40 PM, Chris J. Myers <my...@ec...> wrote:
> Thanks to Leandro Watanabe and the help of his mentors, there is a
> prototype of the arrays package in JSBML. This includes the dimension and
> index data structures, additional mathML constructs (selector and vector),
> validation procedures, and a procedure to flatten to a core model. All of
> these features are still undergoing extensive testing and may still have
> some gaps in their implementation.
>
> The implementation of the flattening procedure has highlighted a few
> corner cases that we would appreciate some input on either on the mailing
> list or at COMBINE next month.
>
> 1) Should all assignments to arrays have explicit dimensions or do we
> allow dimensions to be inferred from the math in the assignment?
>
> As a simple case, assume you have the following:
>
> Parameter
> n := 3
> X[n] <--- array of size n
>
> Assignment Rule
> X = { 1, 2, 3 }
>
> If we allow implicit dimensions, then the flatten procedure than needs to
> determine the size of the vector, make sure it matches the size of X, then
> convert this to:
>
> Assignment Rules
> X_0 := 1
> X_1 := 2
> X_2 := 3
>
> This is made much easier though if we can assume that the assignment rule
> in the original model has these dimensions provided explicitly. Namely,
> the assignment rule is described as follows:
>
> Assignment Rule
> Dimension d0 with size n
> Index d0
> X = { 1, 2, 3 }
>
> Now, flattening is very mechanical and straightforward.
>
> 2) Is a dimension ever make sense for a speciesReference without an id?
> Should it be required to be the same as the dimension for the reaction?
>
> Assume you have the following:
>
> Parameter
> n := 2
>
> Species
> S[n]
>
> Reaction
> R[n]
> a[n] S[d0] --> ()
>
> This gets flattened to:
>
> Species
> S_0
> S_1
>
> Reaction
> R_0: a_0 S_0 --> ()
> R_1: a_1 S_1 --> ()
>
> Basically, the flatten procedure copies all the speciesReferences as it is
> expanding the reactions. However, when there is a speciesReference id, it
> must also expand its id. It seems to me that it would never make sense to
> have an id with a dimension other than the reaction dimension. Also, if
> the reaction has dimensions, then the speciesReference must have them as
> well. That is unless we decide we like implicit dimensions.
>
> 3) Finally, how do you interpret events when there are dimensions on both
> the event and the event assignments. For example, if you have an event of
> size 5 with an event assignment of size 5. Is this 5 events each with one
> event assignment? Or 5 events each with 5 event assignments? I prefer the
> later interpretation. This means you expand the event assignments first,
> then the events. For example:
>
> Parameter
> n := 5
>
> Species
> X[n]
>
> Event
> E[n] with dimension id d0
> Trigger { true, true, true, true, true}
> Delay { 1, 2, 3, 4, 5 }
> Event Assignments
> Dimension ed0 of size n
> X[d0] := 2 * d0 * ed0
>
> Expands to:
>
> E_0
> Trigger true
> Delay 1
> Event Assignments
> X_0 := 0
> X_1 := 0
> X_2 := 0
> X_3 := 0
> X_4 := 0
>
> E_1
> Trigger true
> Delay 2
> Event Assignments
> X_0 := 0
> X_1 := 2
> X_2 := 4
> X_3 := 6
> X_4 := 8
> etc.
>
> Your feedback on all three of these issues is greatly appreciated.
>
> Cheers,
>
> Chris
>
>
>
>
>
>
>
>
>
> ------------------------------------------------------------------------------
> Infragistics Professional
> Build stunning WinForms apps today!
> Reboot your WinForms applications with our WinForms controls.
> Build a bridge from your legacy apps to the future.
>
> http://pubads.g.doubleclick.net/gampad/clk?id=153845071&iu=/4140/ostg.clktrk
> _______________________________________________
> sbml-arrays mailing list
> sbm...@li...
> https://lists.sourceforge.net/lists/listinfo/sbml-arrays
>
|
|
From: Chris J. M. <my...@ec...> - 2014-07-29 01:40:16
|
Thanks to Leandro Watanabe and the help of his mentors, there is a prototype of the arrays package in JSBML. This includes the dimension and index data structures, additional mathML constructs (selector and vector), validation procedures, and a procedure to flatten to a core model. All of these features are still undergoing extensive testing and may still have some gaps in their implementation.
The implementation of the flattening procedure has highlighted a few corner cases that we would appreciate some input on either on the mailing list or at COMBINE next month.
1) Should all assignments to arrays have explicit dimensions or do we allow dimensions to be inferred from the math in the assignment?
As a simple case, assume you have the following:
Parameter
n := 3
X[n] <--- array of size n
Assignment Rule
X = { 1, 2, 3 }
If we allow implicit dimensions, then the flatten procedure than needs to determine the size of the vector, make sure it matches the size of X, then convert this to:
Assignment Rules
X_0 := 1
X_1 := 2
X_2 := 3
This is made much easier though if we can assume that the assignment rule in the original model has these dimensions provided explicitly. Namely, the assignment rule is described as follows:
Assignment Rule
Dimension d0 with size n
Index d0
X = { 1, 2, 3 }
Now, flattening is very mechanical and straightforward.
2) Is a dimension ever make sense for a speciesReference without an id? Should it be required to be the same as the dimension for the reaction?
Assume you have the following:
Parameter
n := 2
Species
S[n]
Reaction
R[n]
a[n] S[d0] --> ()
This gets flattened to:
Species
S_0
S_1
Reaction
R_0: a_0 S_0 --> ()
R_1: a_1 S_1 --> ()
Basically, the flatten procedure copies all the speciesReferences as it is expanding the reactions. However, when there is a speciesReference id, it must also expand its id. It seems to me that it would never make sense to have an id with a dimension other than the reaction dimension. Also, if the reaction has dimensions, then the speciesReference must have them as well. That is unless we decide we like implicit dimensions.
3) Finally, how do you interpret events when there are dimensions on both the event and the event assignments. For example, if you have an event of size 5 with an event assignment of size 5. Is this 5 events each with one event assignment? Or 5 events each with 5 event assignments? I prefer the later interpretation. This means you expand the event assignments first, then the events. For example:
Parameter
n := 5
Species
X[n]
Event
E[n] with dimension id d0
Trigger { true, true, true, true, true}
Delay { 1, 2, 3, 4, 5 }
Event Assignments
Dimension ed0 of size n
X[d0] := 2 * d0 * ed0
Expands to:
E_0
Trigger true
Delay 1
Event Assignments
X_0 := 0
X_1 := 0
X_2 := 0
X_3 := 0
X_4 := 0
E_1
Trigger true
Delay 2
Event Assignments
X_0 := 0
X_1 := 2
X_2 := 4
X_3 := 6
X_4 := 8
etc.
Your feedback on all three of these issues is greatly appreciated.
Cheers,
Chris
|
