Calculating the width of the interval defined by an inequality












6












$begingroup$


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











$endgroup$

















    6












    $begingroup$


    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











    $endgroup$















      6












      6








      6





      $begingroup$


      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











      $endgroup$




      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















      share|improve this question













      share|improve this question




      share|improve this question








      edited Jan 7 at 3:38









      m_goldberg

      85.2k872196




      85.2k872196










      asked Jan 7 at 0:04









      Monire JaliliMonire Jalili

      311




      311






















          3 Answers
          3






          active

          oldest

          votes


















          10












          $begingroup$

          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











          $endgroup$













          • $begingroup$
            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).
            $endgroup$
            – Roman
            Jan 7 at 10:22












          • $begingroup$
            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.
            $endgroup$
            – Henrik Schumacher
            Jan 7 at 10:28










          • $begingroup$
            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])?
            $endgroup$
            – Roman
            Jan 7 at 10:31










          • $begingroup$
            Yes even better!
            $endgroup$
            – Roman
            Jan 7 at 10:32



















          3












          $begingroup$

          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











          $endgroup$





















            2












            $begingroup$

            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











            $endgroup$













              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
              });


              }
              });














              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












              $begingroup$

              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











              $endgroup$













              • $begingroup$
                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).
                $endgroup$
                – Roman
                Jan 7 at 10:22












              • $begingroup$
                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.
                $endgroup$
                – Henrik Schumacher
                Jan 7 at 10:28










              • $begingroup$
                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])?
                $endgroup$
                – Roman
                Jan 7 at 10:31










              • $begingroup$
                Yes even better!
                $endgroup$
                – Roman
                Jan 7 at 10:32
















              10












              $begingroup$

              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











              $endgroup$













              • $begingroup$
                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).
                $endgroup$
                – Roman
                Jan 7 at 10:22












              • $begingroup$
                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.
                $endgroup$
                – Henrik Schumacher
                Jan 7 at 10:28










              • $begingroup$
                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])?
                $endgroup$
                – Roman
                Jan 7 at 10:31










              • $begingroup$
                Yes even better!
                $endgroup$
                – Roman
                Jan 7 at 10:32














              10












              10








              10





              $begingroup$

              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











              $endgroup$



              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

              51.3k469146




              51.3k469146












              • $begingroup$
                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).
                $endgroup$
                – Roman
                Jan 7 at 10:22












              • $begingroup$
                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.
                $endgroup$
                – Henrik Schumacher
                Jan 7 at 10:28










              • $begingroup$
                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])?
                $endgroup$
                – Roman
                Jan 7 at 10:31










              • $begingroup$
                Yes even better!
                $endgroup$
                – Roman
                Jan 7 at 10:32


















              • $begingroup$
                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).
                $endgroup$
                – Roman
                Jan 7 at 10:22












              • $begingroup$
                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.
                $endgroup$
                – Henrik Schumacher
                Jan 7 at 10:28










              • $begingroup$
                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])?
                $endgroup$
                – Roman
                Jan 7 at 10:31










              • $begingroup$
                Yes even better!
                $endgroup$
                – Roman
                Jan 7 at 10:32
















              $begingroup$
              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).
              $endgroup$
              – Roman
              Jan 7 at 10:22






              $begingroup$
              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).
              $endgroup$
              – Roman
              Jan 7 at 10:22














              $begingroup$
              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.
              $endgroup$
              – Henrik Schumacher
              Jan 7 at 10:28




              $begingroup$
              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.
              $endgroup$
              – Henrik Schumacher
              Jan 7 at 10:28












              $begingroup$
              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])?
              $endgroup$
              – Roman
              Jan 7 at 10:31




              $begingroup$
              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])?
              $endgroup$
              – Roman
              Jan 7 at 10:31












              $begingroup$
              Yes even better!
              $endgroup$
              – Roman
              Jan 7 at 10:32




              $begingroup$
              Yes even better!
              $endgroup$
              – Roman
              Jan 7 at 10:32











              3












              $begingroup$

              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











              $endgroup$


















                3












                $begingroup$

                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











                $endgroup$
















                  3












                  3








                  3





                  $begingroup$

                  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











                  $endgroup$



                  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,2011519




                  3,2011519























                      2












                      $begingroup$

                      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











                      $endgroup$


















                        2












                        $begingroup$

                        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











                        $endgroup$
















                          2












                          2








                          2





                          $begingroup$

                          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











                          $endgroup$



                          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

                          85.2k872196




                          85.2k872196






























                              draft saved

                              draft discarded




















































                              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

                              'app-layout' is not a known element: how to share Component with different Modules

                              android studio warns about leanback feature tag usage required on manifest while using Unity exported app?

                              WPF add header to Image with URL pettitions [duplicate]