Calculating the width of the interval defined by an inequality












6















I am looking for a Mathematica function that takes an inequality as the input and gives back the width defined by upper bound - lower bound:



Example:



Fn[1 <= x <= 2.5]



1.5




If the inequality is evaluated to False (e.g., 2 <= x <= 1), then I need the function to return 0.



I truly appreciate your help.










share|improve this question









New contributor




Monire Jalili is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.

























    6















    I am looking for a Mathematica function that takes an inequality as the input and gives back the width defined by upper bound - lower bound:



    Example:



    Fn[1 <= x <= 2.5]



    1.5




    If the inequality is evaluated to False (e.g., 2 <= x <= 1), then I need the function to return 0.



    I truly appreciate your help.










    share|improve this question









    New contributor




    Monire Jalili is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.























      6












      6








      6








      I am looking for a Mathematica function that takes an inequality as the input and gives back the width defined by upper bound - lower bound:



      Example:



      Fn[1 <= x <= 2.5]



      1.5




      If the inequality is evaluated to False (e.g., 2 <= x <= 1), then I need the function to return 0.



      I truly appreciate your help.










      share|improve this question









      New contributor




      Monire Jalili is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.












      I am looking for a Mathematica function that takes an inequality as the input and gives back the width defined by upper bound - lower bound:



      Example:



      Fn[1 <= x <= 2.5]



      1.5




      If the inequality is evaluated to False (e.g., 2 <= x <= 1), then I need the function to return 0.



      I truly appreciate your help.







      function-construction inequalities






      share|improve this question









      New contributor




      Monire Jalili is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.











      share|improve this question









      New contributor




      Monire Jalili is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.









      share|improve this question




      share|improve this question








      edited Jan 7 at 3:38









      m_goldberg

      84.5k872196




      84.5k872196






      New contributor




      Monire Jalili is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.









      asked Jan 7 at 0:04









      Monire JaliliMonire Jalili

      311




      311




      New contributor




      Monire Jalili is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.





      New contributor





      Monire Jalili is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.






      Monire Jalili is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.






















          3 Answers
          3






          active

          oldest

          votes


















          10














          f[ineq_, var_] := RegionMeasure[ImplicitRegion[ineq, var], Length[Flatten[{var}]]]

          f[1 <= x <= 2.5, x]



          1.5




          This works also for some systems of inequalities in several variables:



          f[{1 <= x <= 2.5, 0 <= y <= x}, {x, y}]



          2.625




          Edit:



          This one-argument version treats all symbols in the first argument as variables:



          f[ineq_] := f[ineq, DeleteDuplicates[Cases[ineq, _Symbol]]]





          share|improve this answer


























          • When the dimension of the region is less than Length[var], for example a line embedded in the 2D plane, then RegionMeasure gives the measure in the reduced dimension: f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 1.5 (the length of the line instead of its area), which is not what's usually expected. Fix this with f[ineq_, var_] := RegionMeasure[ImplicitRegion[ineq, var], Length[var]], so that now f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 0 as expected (the line has zero area).

            – Roman
            Jan 7 at 10:22













          • Good point! Thank your for remark; I fixed it. I should have been more cautious; these dimensional issues with regions is actually a frequent source of confusion.

            – Henrik Schumacher
            Jan 7 at 10:28











          • I was too fast in commenting: the function now doesn't work for var=x since Length[x]=0. Maybe two separate definitions for var_Symbol (using dimension 1) and for var_List (using dimensions Length[var])?

            – Roman
            Jan 7 at 10:31











          • Yes even better!

            – Roman
            Jan 7 at 10:32



















          3














          fn[expr_] := Module[{},
          If[! expr, Return [0]];
          If[Head[expr] == Inequality, Return[Abs[expr[[5]] - expr[[1]]]]];
          Return[Abs[expr[[3]] - expr[[1]]]];
          ]

          fn[2 <= x <= 1]
          (*0*)

          fn[1 <= x <= 2.5]
          (*1.5*)

          fn[2.5 > x > 1]
          (*1.5*)


          Don't know if this works in all cases, but works in the simple cases you provide plus some.






          share|improve this answer

































            2














            To get a function that would handle the all the kinds of arguments I want it to handle turned out to be more of a challenge than I anticipated, but here is what I came up with.



            Edit



            This version is handle expressions that evaluate to False more robustly.



            ClearAll[fn, helper1, helper2]

            SetAttributes[fn, HoldFirst]
            fn[expr_] := If[expr, helper1[expr], helper2[expr], helper1[expr]]

            SetAttributes[helper1, HoldFirst]
            helper1[expr : _Inequality | _Less | _LessEqual | _Greater | _GreaterEqual] :=
            Module[{args = List @@ Unevaluated[expr], a, b},
            {a, b} = MinMax[Select[args, NumericQ]];
            b - a]
            helper1[___] = $Failed;

            SetAttributes[helper2, HoldFirst]
            helper2[expr : _Inequality | _Less | _LessEqual | _Greater | _GreaterEqual] := 0;
            helper2[___] = $Failed;

            ###Tests

            fn[1 < x <= 2.5]



            1.5




            fn[1 < x <= π]



            -1 + π




            fn[1 >= x > π]



            0




            fn[1 >= x > -1]



            2




            fn[-1 < 1 <= 2.5]



            3.5




            fn[1 < x < 3 < y < 5]



            4




            fn[1.5 < 2]



            0.5




            fn["garbage"]



            $Failed




            fn[1 == 1]



            $Failed




             fn[1 != 1]



            $Failed







            share|improve this answer

























              Your Answer





              StackExchange.ifUsing("editor", function () {
              return StackExchange.using("mathjaxEditing", function () {
              StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
              StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["$", "$"], ["\\(","\\)"]]);
              });
              });
              }, "mathjax-editing");

              StackExchange.ready(function() {
              var channelOptions = {
              tags: "".split(" "),
              id: "387"
              };
              initTagRenderer("".split(" "), "".split(" "), channelOptions);

              StackExchange.using("externalEditor", function() {
              // Have to fire editor after snippets, if snippets enabled
              if (StackExchange.settings.snippets.snippetsEnabled) {
              StackExchange.using("snippets", function() {
              createEditor();
              });
              }
              else {
              createEditor();
              }
              });

              function createEditor() {
              StackExchange.prepareEditor({
              heartbeatType: 'answer',
              autoActivateHeartbeat: false,
              convertImagesToLinks: false,
              noModals: true,
              showLowRepImageUploadWarning: true,
              reputationToPostImages: null,
              bindNavPrevention: true,
              postfix: "",
              imageUploader: {
              brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
              contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
              allowUrls: true
              },
              onDemand: true,
              discardSelector: ".discard-answer"
              ,immediatelyShowMarkdownHelp:true
              });


              }
              });






              Monire Jalili is a new contributor. Be nice, and check out our Code of Conduct.










              draft saved

              draft discarded


















              StackExchange.ready(
              function () {
              StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f188960%2fcalculating-the-width-of-the-interval-defined-by-an-inequality%23new-answer', 'question_page');
              }
              );

              Post as a guest















              Required, but never shown

























              3 Answers
              3






              active

              oldest

              votes








              3 Answers
              3






              active

              oldest

              votes









              active

              oldest

              votes






              active

              oldest

              votes









              10














              f[ineq_, var_] := RegionMeasure[ImplicitRegion[ineq, var], Length[Flatten[{var}]]]

              f[1 <= x <= 2.5, x]



              1.5




              This works also for some systems of inequalities in several variables:



              f[{1 <= x <= 2.5, 0 <= y <= x}, {x, y}]



              2.625




              Edit:



              This one-argument version treats all symbols in the first argument as variables:



              f[ineq_] := f[ineq, DeleteDuplicates[Cases[ineq, _Symbol]]]





              share|improve this answer


























              • When the dimension of the region is less than Length[var], for example a line embedded in the 2D plane, then RegionMeasure gives the measure in the reduced dimension: f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 1.5 (the length of the line instead of its area), which is not what's usually expected. Fix this with f[ineq_, var_] := RegionMeasure[ImplicitRegion[ineq, var], Length[var]], so that now f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 0 as expected (the line has zero area).

                – Roman
                Jan 7 at 10:22













              • Good point! Thank your for remark; I fixed it. I should have been more cautious; these dimensional issues with regions is actually a frequent source of confusion.

                – Henrik Schumacher
                Jan 7 at 10:28











              • I was too fast in commenting: the function now doesn't work for var=x since Length[x]=0. Maybe two separate definitions for var_Symbol (using dimension 1) and for var_List (using dimensions Length[var])?

                – Roman
                Jan 7 at 10:31











              • Yes even better!

                – Roman
                Jan 7 at 10:32
















              10














              f[ineq_, var_] := RegionMeasure[ImplicitRegion[ineq, var], Length[Flatten[{var}]]]

              f[1 <= x <= 2.5, x]



              1.5




              This works also for some systems of inequalities in several variables:



              f[{1 <= x <= 2.5, 0 <= y <= x}, {x, y}]



              2.625




              Edit:



              This one-argument version treats all symbols in the first argument as variables:



              f[ineq_] := f[ineq, DeleteDuplicates[Cases[ineq, _Symbol]]]





              share|improve this answer


























              • When the dimension of the region is less than Length[var], for example a line embedded in the 2D plane, then RegionMeasure gives the measure in the reduced dimension: f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 1.5 (the length of the line instead of its area), which is not what's usually expected. Fix this with f[ineq_, var_] := RegionMeasure[ImplicitRegion[ineq, var], Length[var]], so that now f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 0 as expected (the line has zero area).

                – Roman
                Jan 7 at 10:22













              • Good point! Thank your for remark; I fixed it. I should have been more cautious; these dimensional issues with regions is actually a frequent source of confusion.

                – Henrik Schumacher
                Jan 7 at 10:28











              • I was too fast in commenting: the function now doesn't work for var=x since Length[x]=0. Maybe two separate definitions for var_Symbol (using dimension 1) and for var_List (using dimensions Length[var])?

                – Roman
                Jan 7 at 10:31











              • Yes even better!

                – Roman
                Jan 7 at 10:32














              10












              10








              10







              f[ineq_, var_] := RegionMeasure[ImplicitRegion[ineq, var], Length[Flatten[{var}]]]

              f[1 <= x <= 2.5, x]



              1.5




              This works also for some systems of inequalities in several variables:



              f[{1 <= x <= 2.5, 0 <= y <= x}, {x, y}]



              2.625




              Edit:



              This one-argument version treats all symbols in the first argument as variables:



              f[ineq_] := f[ineq, DeleteDuplicates[Cases[ineq, _Symbol]]]





              share|improve this answer















              f[ineq_, var_] := RegionMeasure[ImplicitRegion[ineq, var], Length[Flatten[{var}]]]

              f[1 <= x <= 2.5, x]



              1.5




              This works also for some systems of inequalities in several variables:



              f[{1 <= x <= 2.5, 0 <= y <= x}, {x, y}]



              2.625




              Edit:



              This one-argument version treats all symbols in the first argument as variables:



              f[ineq_] := f[ineq, DeleteDuplicates[Cases[ineq, _Symbol]]]






              share|improve this answer














              share|improve this answer



              share|improve this answer








              edited Jan 7 at 15:14

























              answered Jan 7 at 1:00









              Henrik SchumacherHenrik Schumacher

              50.1k469144




              50.1k469144













              • When the dimension of the region is less than Length[var], for example a line embedded in the 2D plane, then RegionMeasure gives the measure in the reduced dimension: f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 1.5 (the length of the line instead of its area), which is not what's usually expected. Fix this with f[ineq_, var_] := RegionMeasure[ImplicitRegion[ineq, var], Length[var]], so that now f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 0 as expected (the line has zero area).

                – Roman
                Jan 7 at 10:22













              • Good point! Thank your for remark; I fixed it. I should have been more cautious; these dimensional issues with regions is actually a frequent source of confusion.

                – Henrik Schumacher
                Jan 7 at 10:28











              • I was too fast in commenting: the function now doesn't work for var=x since Length[x]=0. Maybe two separate definitions for var_Symbol (using dimension 1) and for var_List (using dimensions Length[var])?

                – Roman
                Jan 7 at 10:31











              • Yes even better!

                – Roman
                Jan 7 at 10:32



















              • When the dimension of the region is less than Length[var], for example a line embedded in the 2D plane, then RegionMeasure gives the measure in the reduced dimension: f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 1.5 (the length of the line instead of its area), which is not what's usually expected. Fix this with f[ineq_, var_] := RegionMeasure[ImplicitRegion[ineq, var], Length[var]], so that now f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 0 as expected (the line has zero area).

                – Roman
                Jan 7 at 10:22













              • Good point! Thank your for remark; I fixed it. I should have been more cautious; these dimensional issues with regions is actually a frequent source of confusion.

                – Henrik Schumacher
                Jan 7 at 10:28











              • I was too fast in commenting: the function now doesn't work for var=x since Length[x]=0. Maybe two separate definitions for var_Symbol (using dimension 1) and for var_List (using dimensions Length[var])?

                – Roman
                Jan 7 at 10:31











              • Yes even better!

                – Roman
                Jan 7 at 10:32

















              When the dimension of the region is less than Length[var], for example a line embedded in the 2D plane, then RegionMeasure gives the measure in the reduced dimension: f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 1.5 (the length of the line instead of its area), which is not what's usually expected. Fix this with f[ineq_, var_] := RegionMeasure[ImplicitRegion[ineq, var], Length[var]], so that now f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 0 as expected (the line has zero area).

              – Roman
              Jan 7 at 10:22







              When the dimension of the region is less than Length[var], for example a line embedded in the 2D plane, then RegionMeasure gives the measure in the reduced dimension: f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 1.5 (the length of the line instead of its area), which is not what's usually expected. Fix this with f[ineq_, var_] := RegionMeasure[ImplicitRegion[ineq, var], Length[var]], so that now f[{1 <= x <= 2.5, y == 0}, {x, y}] gives 0 as expected (the line has zero area).

              – Roman
              Jan 7 at 10:22















              Good point! Thank your for remark; I fixed it. I should have been more cautious; these dimensional issues with regions is actually a frequent source of confusion.

              – Henrik Schumacher
              Jan 7 at 10:28





              Good point! Thank your for remark; I fixed it. I should have been more cautious; these dimensional issues with regions is actually a frequent source of confusion.

              – Henrik Schumacher
              Jan 7 at 10:28













              I was too fast in commenting: the function now doesn't work for var=x since Length[x]=0. Maybe two separate definitions for var_Symbol (using dimension 1) and for var_List (using dimensions Length[var])?

              – Roman
              Jan 7 at 10:31





              I was too fast in commenting: the function now doesn't work for var=x since Length[x]=0. Maybe two separate definitions for var_Symbol (using dimension 1) and for var_List (using dimensions Length[var])?

              – Roman
              Jan 7 at 10:31













              Yes even better!

              – Roman
              Jan 7 at 10:32





              Yes even better!

              – Roman
              Jan 7 at 10:32











              3














              fn[expr_] := Module[{},
              If[! expr, Return [0]];
              If[Head[expr] == Inequality, Return[Abs[expr[[5]] - expr[[1]]]]];
              Return[Abs[expr[[3]] - expr[[1]]]];
              ]

              fn[2 <= x <= 1]
              (*0*)

              fn[1 <= x <= 2.5]
              (*1.5*)

              fn[2.5 > x > 1]
              (*1.5*)


              Don't know if this works in all cases, but works in the simple cases you provide plus some.






              share|improve this answer






























                3














                fn[expr_] := Module[{},
                If[! expr, Return [0]];
                If[Head[expr] == Inequality, Return[Abs[expr[[5]] - expr[[1]]]]];
                Return[Abs[expr[[3]] - expr[[1]]]];
                ]

                fn[2 <= x <= 1]
                (*0*)

                fn[1 <= x <= 2.5]
                (*1.5*)

                fn[2.5 > x > 1]
                (*1.5*)


                Don't know if this works in all cases, but works in the simple cases you provide plus some.






                share|improve this answer




























                  3












                  3








                  3







                  fn[expr_] := Module[{},
                  If[! expr, Return [0]];
                  If[Head[expr] == Inequality, Return[Abs[expr[[5]] - expr[[1]]]]];
                  Return[Abs[expr[[3]] - expr[[1]]]];
                  ]

                  fn[2 <= x <= 1]
                  (*0*)

                  fn[1 <= x <= 2.5]
                  (*1.5*)

                  fn[2.5 > x > 1]
                  (*1.5*)


                  Don't know if this works in all cases, but works in the simple cases you provide plus some.






                  share|improve this answer















                  fn[expr_] := Module[{},
                  If[! expr, Return [0]];
                  If[Head[expr] == Inequality, Return[Abs[expr[[5]] - expr[[1]]]]];
                  Return[Abs[expr[[3]] - expr[[1]]]];
                  ]

                  fn[2 <= x <= 1]
                  (*0*)

                  fn[1 <= x <= 2.5]
                  (*1.5*)

                  fn[2.5 > x > 1]
                  (*1.5*)


                  Don't know if this works in all cases, but works in the simple cases you provide plus some.







                  share|improve this answer














                  share|improve this answer



                  share|improve this answer








                  edited Jan 7 at 9:04

























                  answered Jan 7 at 0:55









                  Bill WattsBill Watts

                  3,0311517




                  3,0311517























                      2














                      To get a function that would handle the all the kinds of arguments I want it to handle turned out to be more of a challenge than I anticipated, but here is what I came up with.



                      Edit



                      This version is handle expressions that evaluate to False more robustly.



                      ClearAll[fn, helper1, helper2]

                      SetAttributes[fn, HoldFirst]
                      fn[expr_] := If[expr, helper1[expr], helper2[expr], helper1[expr]]

                      SetAttributes[helper1, HoldFirst]
                      helper1[expr : _Inequality | _Less | _LessEqual | _Greater | _GreaterEqual] :=
                      Module[{args = List @@ Unevaluated[expr], a, b},
                      {a, b} = MinMax[Select[args, NumericQ]];
                      b - a]
                      helper1[___] = $Failed;

                      SetAttributes[helper2, HoldFirst]
                      helper2[expr : _Inequality | _Less | _LessEqual | _Greater | _GreaterEqual] := 0;
                      helper2[___] = $Failed;

                      ###Tests

                      fn[1 < x <= 2.5]



                      1.5




                      fn[1 < x <= π]



                      -1 + π




                      fn[1 >= x > π]



                      0




                      fn[1 >= x > -1]



                      2




                      fn[-1 < 1 <= 2.5]



                      3.5




                      fn[1 < x < 3 < y < 5]



                      4




                      fn[1.5 < 2]



                      0.5




                      fn["garbage"]



                      $Failed




                      fn[1 == 1]



                      $Failed




                       fn[1 != 1]



                      $Failed







                      share|improve this answer






























                        2














                        To get a function that would handle the all the kinds of arguments I want it to handle turned out to be more of a challenge than I anticipated, but here is what I came up with.



                        Edit



                        This version is handle expressions that evaluate to False more robustly.



                        ClearAll[fn, helper1, helper2]

                        SetAttributes[fn, HoldFirst]
                        fn[expr_] := If[expr, helper1[expr], helper2[expr], helper1[expr]]

                        SetAttributes[helper1, HoldFirst]
                        helper1[expr : _Inequality | _Less | _LessEqual | _Greater | _GreaterEqual] :=
                        Module[{args = List @@ Unevaluated[expr], a, b},
                        {a, b} = MinMax[Select[args, NumericQ]];
                        b - a]
                        helper1[___] = $Failed;

                        SetAttributes[helper2, HoldFirst]
                        helper2[expr : _Inequality | _Less | _LessEqual | _Greater | _GreaterEqual] := 0;
                        helper2[___] = $Failed;

                        ###Tests

                        fn[1 < x <= 2.5]



                        1.5




                        fn[1 < x <= π]



                        -1 + π




                        fn[1 >= x > π]



                        0




                        fn[1 >= x > -1]



                        2




                        fn[-1 < 1 <= 2.5]



                        3.5




                        fn[1 < x < 3 < y < 5]



                        4




                        fn[1.5 < 2]



                        0.5




                        fn["garbage"]



                        $Failed




                        fn[1 == 1]



                        $Failed




                         fn[1 != 1]



                        $Failed







                        share|improve this answer




























                          2












                          2








                          2







                          To get a function that would handle the all the kinds of arguments I want it to handle turned out to be more of a challenge than I anticipated, but here is what I came up with.



                          Edit



                          This version is handle expressions that evaluate to False more robustly.



                          ClearAll[fn, helper1, helper2]

                          SetAttributes[fn, HoldFirst]
                          fn[expr_] := If[expr, helper1[expr], helper2[expr], helper1[expr]]

                          SetAttributes[helper1, HoldFirst]
                          helper1[expr : _Inequality | _Less | _LessEqual | _Greater | _GreaterEqual] :=
                          Module[{args = List @@ Unevaluated[expr], a, b},
                          {a, b} = MinMax[Select[args, NumericQ]];
                          b - a]
                          helper1[___] = $Failed;

                          SetAttributes[helper2, HoldFirst]
                          helper2[expr : _Inequality | _Less | _LessEqual | _Greater | _GreaterEqual] := 0;
                          helper2[___] = $Failed;

                          ###Tests

                          fn[1 < x <= 2.5]



                          1.5




                          fn[1 < x <= π]



                          -1 + π




                          fn[1 >= x > π]



                          0




                          fn[1 >= x > -1]



                          2




                          fn[-1 < 1 <= 2.5]



                          3.5




                          fn[1 < x < 3 < y < 5]



                          4




                          fn[1.5 < 2]



                          0.5




                          fn["garbage"]



                          $Failed




                          fn[1 == 1]



                          $Failed




                           fn[1 != 1]



                          $Failed







                          share|improve this answer















                          To get a function that would handle the all the kinds of arguments I want it to handle turned out to be more of a challenge than I anticipated, but here is what I came up with.



                          Edit



                          This version is handle expressions that evaluate to False more robustly.



                          ClearAll[fn, helper1, helper2]

                          SetAttributes[fn, HoldFirst]
                          fn[expr_] := If[expr, helper1[expr], helper2[expr], helper1[expr]]

                          SetAttributes[helper1, HoldFirst]
                          helper1[expr : _Inequality | _Less | _LessEqual | _Greater | _GreaterEqual] :=
                          Module[{args = List @@ Unevaluated[expr], a, b},
                          {a, b} = MinMax[Select[args, NumericQ]];
                          b - a]
                          helper1[___] = $Failed;

                          SetAttributes[helper2, HoldFirst]
                          helper2[expr : _Inequality | _Less | _LessEqual | _Greater | _GreaterEqual] := 0;
                          helper2[___] = $Failed;

                          ###Tests

                          fn[1 < x <= 2.5]



                          1.5




                          fn[1 < x <= π]



                          -1 + π




                          fn[1 >= x > π]



                          0




                          fn[1 >= x > -1]



                          2




                          fn[-1 < 1 <= 2.5]



                          3.5




                          fn[1 < x < 3 < y < 5]



                          4




                          fn[1.5 < 2]



                          0.5




                          fn["garbage"]



                          $Failed




                          fn[1 == 1]



                          $Failed




                           fn[1 != 1]



                          $Failed








                          share|improve this answer














                          share|improve this answer



                          share|improve this answer








                          edited Jan 7 at 14:51

























                          answered Jan 7 at 4:52









                          m_goldbergm_goldberg

                          84.5k872196




                          84.5k872196






















                              Monire Jalili is a new contributor. Be nice, and check out our Code of Conduct.










                              draft saved

                              draft discarded


















                              Monire Jalili is a new contributor. Be nice, and check out our Code of Conduct.













                              Monire Jalili is a new contributor. Be nice, and check out our Code of Conduct.












                              Monire Jalili is a new contributor. Be nice, and check out our Code of Conduct.
















                              Thanks for contributing an answer to Mathematica Stack Exchange!


                              • Please be sure to answer the question. Provide details and share your research!

                              But avoid



                              • Asking for help, clarification, or responding to other answers.

                              • Making statements based on opinion; back them up with references or personal experience.


                              Use MathJax to format equations. MathJax reference.


                              To learn more, see our tips on writing great answers.




                              draft saved


                              draft discarded














                              StackExchange.ready(
                              function () {
                              StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f188960%2fcalculating-the-width-of-the-interval-defined-by-an-inequality%23new-answer', 'question_page');
                              }
                              );

                              Post as a guest















                              Required, but never shown





















































                              Required, but never shown














                              Required, but never shown












                              Required, but never shown







                              Required, but never shown

































                              Required, but never shown














                              Required, but never shown












                              Required, but never shown







                              Required, but never shown







                              Popular posts from this blog

                              Mario Kart Wii

                              The Binding of Isaac: Rebirth/Afterbirth

                              What does “Dominus providebit” mean?