├── .gitignore
├── CastExtensions.cs
├── DictionaryExtensions.cs
├── DotNetExtensions.csproj
├── DotNetExtensions.sln
├── DotNetExtensionsTestProject1
    ├── DictionaryExtensionsTests.cs
    ├── DotNetExtensionsTests.csproj
    └── Properties
    │   └── AssemblyInfo.cs
├── EnumerableExtensions.cs
├── Numerics.cs
├── Properties
    └── AssemblyInfo.cs
├── README.md
├── Viterbi
    ├── FunctionBasedViterbi.cs
    ├── Properties
    │   └── AssemblyInfo.cs
    ├── Viterbi.csproj
    ├── contractsUserdoc.pdf
    └── contractsUserdoc.txt
├── ViterbiTests
    ├── Properties
    │   └── AssemblyInfo.cs
    ├── ViterbiTest1.cs
    ├── ViterbiTests.csproj
    └── bin
    │   ├── Debug
    │       ├── System.CoreEx.dll
    │       ├── System.Interactive.dll
    │       └── System.Reactive.dll
    │   └── Release
    │       ├── System.CoreEx.dll
    │       ├── System.Interactive.dll
    │       └── System.Reactive.dll
└── iSynapticSubset
    ├── IMaybe.cs
    ├── Maybe.cs
    ├── State.cs
    ├── TrySelector.cs
    └── Unit.cs


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.suo
 2 | *.user
 3 | *.vs10x
 4 | *.docstates
 5 | *.dotcover
 6 | bin/
 7 | obj/
 8 | Build/
 9 | _ReSharper.*/
10 | TestResults/


--------------------------------------------------------------------------------
/CastExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | 
 6 | namespace Experimental.DotNetExtensions
 7 | {
 8 |     public static class CastExtensions
 9 |     {
10 |         public static T MustBe<T>(this object self)
11 |             where T : class
12 |         {
13 |             var that = self as T;
14 |             if (that == null)
15 |             {
16 |                 throw new InvalidOperationException(
17 |                     string.Format(
18 |                         "Expected object {0} to have type {1}",
19 |                         self.ToString(),
20 |                         typeof(T).ToString()));
21 |             }
22 |             return that;
23 |         }
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/DictionaryExtensions.cs:
--------------------------------------------------------------------------------
  1 | // The MIT License
  2 | 
  3 | // Portions Copyright (c) 2011 Jordan E. Terrell, licensed to 
  4 | // Microsoft Corporation under the MIT license (copied below).
  5 | // 
  6 | // Portions Copyright (c) 2011 Microsoft Corporation
  7 | 
  8 | // Permission is hereby granted, free of charge, to any person obtaining
  9 | // a copy of this software and associated documentation files (the
 10 | // "Software"), to deal in the Software without restriction, including
 11 | // without limitation the rights to use, copy, modify, merge, publish,
 12 | // distribute, sublicense, and/or sell copies of the Software, and to
 13 | // permit persons to whom the Software is furnished to do so, subject to
 14 | // the following conditions:
 15 | 
 16 | // The above copyright notice and this permission notice shall be
 17 | // included in all copies or substantial portions of the Software.
 18 | 
 19 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 20 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 21 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 22 | // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 23 | // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 24 | // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 25 | // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 26 | 
 27 | using System;
 28 | using System.Collections.Generic;
 29 | using System.Diagnostics.Contracts;
 30 | using System.Linq;
 31 | using Experimental.DotNetExtensions.iSynaptic;
 32 | 
 33 | namespace Experimental.DotNetExtensions
 34 | {
 35 |     /// <summary>
 36 |     /// Extensions to the IDictionary interface, supporting chainable dictionary combinators.
 37 |     /// </summary>
 38 |     public static class IDictionary
 39 |     {
 40 |         /// <summary>
 41 |         /// Creation through explicitly supplied first values.
 42 |         /// </summary>
 43 |         /// <typeparam name="K">The type of keys in the dictionary.</typeparam>
 44 |         /// <typeparam name="V">The type of values in the dictionary.</typeparam>
 45 |         /// <param name="key">A value of type K.</param>
 46 |         /// <param name="value">A value of type V.</param>
 47 |         /// <returns>The IDictionary interface of a new dictionary.</returns>
 48 |         public static IDictionary<K, V> AddUnconditionally<K, V>(K key, V value)
 49 |         {
 50 |             return new Dictionary<K, V>()
 51 |                 .AddUnconditionally(key, value);
 52 |         }
 53 | 
 54 |         /// <summary>
 55 |         /// Creation through explicitly supplied first values.
 56 |         /// </summary>
 57 |         /// <typeparam name="K">The type of keys in the dictionary.</typeparam>
 58 |         /// <typeparam name="V">The type of values in the dictionary.</typeparam>
 59 |         /// <param name="key">A value of type K.</param>
 60 |         /// <param name="value">A value of type V.</param>
 61 |         /// <returns>The IDictionary interface of a new dictionary.</returns>
 62 |         public static IDictionary<K, V> AddConditionally<K, V>(K key, V value)
 63 |         {
 64 |             return new Dictionary<K, V>()
 65 |                 .AddConditionally(key, value);
 66 |         }
 67 | 
 68 |         /// <summary>
 69 |         /// Creation based on types of ignored values. Recommended usage IDictionary.Create(default(K), default(V)).
 70 |         /// </summary>
 71 |         /// <typeparam name="K">The type of keys in the dictionary.</typeparam>
 72 |         /// <typeparam name="V">The type of values in the dictionary.</typeparam>
 73 |         /// <param name="key">A value of type K to assist type inference; ignored.</param>
 74 |         /// <param name="value">A value of type V to assist type inference; ignored.</param>
 75 |         /// <returns>The IDictionary interface of a new dictionary.</returns>
 76 |         public static IDictionary<K, V> Create<K, V>(K key, V value)
 77 |         {
 78 |             return new Dictionary<K, V>();
 79 |         }
 80 | 
 81 |         /// <summary>
 82 |         /// Creation based on explicitly supplied type arguments.
 83 |         /// </summary>
 84 |         /// <typeparam name="K">The type of keys in the dictionary.</typeparam>
 85 |         /// <typeparam name="V">The type of values in the dictionary.</typeparam>
 86 |         /// <returns>The IDictionary interface of a new dictionary.</returns>
 87 |         public static IDictionary<K, V> Create<K, V>()
 88 |         {
 89 |             return new Dictionary<K, V>();
 90 |         }
 91 | 
 92 |         /// <summary>
 93 |         /// Returns a Maybe instance encapsulating a potentially absent value.
 94 |         /// </summary>
 95 |         /// <typeparam name="K">The type of keys in the dictionary.</typeparam>
 96 |         /// <typeparam name="V">The type of values in the dictionary.</typeparam>
 97 |         /// <param name="theDictionary">The input dictionary.</param>
 98 |         /// <param name="key">The key to try.</param>
 99 |         /// <returns>The potentially absent value encapsulated in a Maybe.</returns>
100 |         public static Maybe<V> TryGetValue<K, V>(
101 |             this IDictionary<K, V> theDictionary,
102 |             K key)
103 |         {
104 |             //Contract.Requires(null != theDictionary, "theDictionary");
105 | 
106 |             V retrieved = default(V);
107 | 
108 |             return theDictionary.TryGetValue(key, out retrieved) 
109 |                 ? new Maybe<V>(retrieved)
110 |                 : Maybe<V>.NoValue;
111 |         }
112 | 
113 |         /// <summary>
114 |         /// Add whether the key is present or not.
115 |         /// </summary>
116 |         /// <typeparam name="K">The type of keys in the dictionary.</typeparam>
117 |         /// <typeparam name="V">The type of values in the dictionary.</typeparam>
118 |         /// <param name="theDictionary">The input dictionary.</param>
119 |         /// <param name="keyValuePair">The input key-value pair.</param>
120 |         /// <returns>The modified dictionary.</returns>
121 |         public static IDictionary<K, V> AddUnconditionally<K, V>(
122 |             this IDictionary<K, V> theDictionary,
123 |             KeyValuePair<K, V> keyValuePair)
124 |         {
125 |             Contract.Requires(theDictionary != null);
126 | 
127 | #if (false)
128 |             theDictionary[keyValuePair.Key] = keyValuePair.Value;
129 |             return theDictionary;
130 | #else
131 |             // Take the kvp . . .
132 |             return keyValuePair
133 |                 // Bring it into the state monad with the IDictionary as state
134 |                 // and the default propagator that does nothing to the state . . .
135 |                 .ToState<IDictionary<K, V>, KeyValuePair<K, V>>()
136 |                 // Shove this through a transformer that produces a bool and state . . .
137 |                 .Bind<IDictionary<K, V>, KeyValuePair<K, V>, bool>(
138 |                 // From the provided kvp . . .
139 |                     kvp => new State<IDictionary<K, V>, bool>(
140 |                         // with a propagator that UNCONDITIONALLY puts the kvp in 
141 |                         // the dictionary, and reports whether the key was already
142 |                         // present . . .
143 | #if (false)
144 |                         propagator: dict => ValueStatePair.Create(dict
145 |                         // TODO: Investigate intermittent stress failure of the Maybe monad!
146 |                             // via the Maybe monad . . .
147 |                             .TryGetValue(kvp.Key)
148 |                             // if the value was not in the dictionary, add it . . .
149 |                             .OnNoValue(() => dict.Add(key: kvp.Key, value: kvp.Value))
150 |                             // if the value was in the dictionary, replace it . . .
151 |                             .OnValue(_ => dict[kvp.Key] = kvp.Value)
152 |                             // be thread-safe . . .
153 |                             .Synchronize(dict)
154 |                             // provide the bool . . .
155 |                             .HasValue,
156 |                             // and the original dictionary.
157 |                             dict)))
158 | #else
159 |                         propagator: dict =>
160 |                         {
161 |                             var value = default(V);
162 |                             var hasValue = dict.TryGetValue(kvp.Key, out value);
163 |                             if (hasValue)
164 |                                 dict[kvp.Key] = kvp.Value;
165 |                             else
166 |                                 dict.Add(key: kvp.Key, value: kvp.Value);
167 | 
168 |                             return ValueStatePair.Create(hasValue, dict);
169 |                         }))
170 | #endif
171 |                 // Apply the newly bound state to the input dictionary . . .
172 |                 .Propagator(theDictionary)
173 |                 // Extract the dictionary from the tuple and return it:
174 |                 .State
175 |                 ;
176 | 
177 |             // Sadly, the bool info about whether the key was in the dictionary
178 |             // is lost, the price we pay to thread the dictionary out. 
179 | #endif
180 |         }
181 | 
182 |         /// <summary>
183 |         /// Add whether the key is present or not.
184 |         /// </summary>
185 |         /// <typeparam name="K">The type of keys in the dictionary.</typeparam>
186 |         /// <typeparam name="V">The type of values in the dictionary.</typeparam>
187 |         /// <param name="theDictionary">The input dictionary.</param>
188 |         /// <param name="key">The key to install.</param>
189 |         /// <param name="value">The value to install.</param>
190 |         /// <returns>The modified dictionary.</returns>
191 |         public static IDictionary<K, V> AddUnconditionally<K, V>(
192 |             this IDictionary<K, V> theDictionary,
193 |             K key,
194 |             V value)
195 |         {
196 |             return theDictionary
197 |                 .AddUnconditionally(
198 |                     new KeyValuePair<K, V>(key: key, value: value));
199 |         }
200 | 
201 |         /// <summary>
202 |         /// Add only if key is NOT already present.
203 |         /// </summary>
204 |         /// <typeparam name="K">The type of keys in the dictionary.</typeparam>
205 |         /// <typeparam name="V">The type of values in the dictionary.</typeparam>
206 |         /// <param name="theDictionary">The input dictionary.</param>
207 |         /// <param name="keyValuePair">The input key-value pair.</param>
208 |         /// <returns>The modified dictionary.</returns>
209 |         public static IDictionary<K, V> AddConditionally<K, V>(
210 |             this IDictionary<K, V> theDictionary,
211 |             KeyValuePair<K, V> kvpInput)
212 |         {
213 |             Contract.Requires(theDictionary != null);
214 | 
215 | #if (false)
216 |             var value = default(V);
217 |             var hasValue = theDictionary.TryGetValue(kvpInput.Key, out value);
218 |             if (!hasValue)
219 |                 theDictionary[kvpInput.Key] = kvpInput.Value;
220 |             return theDictionary;
221 | #else
222 | 
223 |             // Take the kvp . . .
224 |             return kvpInput
225 |                 // Bring it into the state monad with the IDictionary as state
226 |                 // and the default propagator that does nothing to the state . . .
227 |                 .ToState<IDictionary<K, V>, KeyValuePair<K, V>>()
228 |                 // Shove this through a transformer that produces a bool and state . . .
229 |                 .Bind<IDictionary<K, V>, KeyValuePair<K, V>, bool>(
230 |                 // From the provided kvp . . .
231 |                     kvp => new State<IDictionary<K, V>, bool>(
232 |                         // with a propagator that CONDITIONALLY puts the kvp in 
233 |                         // the dictionary, and reports whether the key was already
234 |                         // present . . .
235 | #if (false)
236 |                         propagator: dict => ValueStatePair.Create(dict
237 |                         // TODO: investigate failure of the Maybe monad!
238 |                             // via the Maybe monad . . .
239 |                             .TryGetValue(kvp.Key)
240 |                             // if the value was not in the dictionary, add it . . .
241 |                             .OnNoValue(() => dict.Add(key: kvp.Key, value: kvp.Value))
242 |                             // be thread safe . . .
243 |                             .Synchronize(dict)
244 |                             // provide the bool . . .
245 |                             .HasValue, 
246 |                             // and the original dictionary.
247 |                             dict)))
248 | #else
249 |                         propagator: dict =>
250 |                         {
251 |                             var value = default(V);
252 |                             var hasValue = dict.TryGetValue(kvp.Key, out value);
253 |                             if (!hasValue)
254 |                                 dict.Add(key: kvp.Key, value: kvp.Value);
255 |                             return ValueStatePair.Create(hasValue, dict);
256 |                         }))
257 | #endif
258 |                 // Apply the newly bound state to the input dictionary . . .
259 |                 .Propagator(theDictionary)
260 |                 // Extract the dictionary from the tuple and return it:
261 |                 .State
262 |                 ;
263 | 
264 |             // Sadly, the info about whether the key was in the dictionary
265 |             // is lost, the price we pay to thread the dictionary through. 
266 | #endif
267 |         }
268 | 
269 |         public static IDictionary<K, V> AddConditionally<K, V>(
270 |             this IDictionary<K, V> theDictionary,
271 |             K key,
272 |             V value)
273 |         {
274 |             return theDictionary
275 |                 .AddConditionally(
276 |                     new KeyValuePair<K, V>(key: key, value: value));
277 |         }
278 | 
279 |         /// <summary>
280 |         /// Look up the value, and return the default of type 'Value' if the key is not present.
281 |         /// </summary>
282 |         /// <typeparam name="K">The type of keys.</typeparam>
283 |         /// <typeparam name="V">The type of values.</typeparam>
284 |         /// <param name="theDictionary">The dictionary in which to look up values.</param>
285 |         /// <param name="key">They key to look up.</param>
286 |         /// <returns>The value of type T corresponding to the key if the key is present in the dictionary, otherwise, the defined default value for the type T of all values.</returns>
287 |         public static V GetValueOrDefault<K, V>(
288 |             this IDictionary<K, V> theDictionary,
289 |             K key)
290 |             where V : class
291 |         {
292 |             V result;
293 |             var foundP = theDictionary.TryGetValue(key, out result);
294 |             Contract.Assert(foundP == true || result == null);
295 |             return result ?? default(V);
296 |         }
297 | 
298 |         public static V GetValueOrDefaultValueType<K, V>(
299 |             this IDictionary<K, V> theDictionary,
300 |             K key)
301 |             where V : struct
302 |         {
303 |             V result;
304 |             var foundP = theDictionary.TryGetValue(key, out result);
305 |             Contract.Assert(foundP == true || result.Equals(default(V)));
306 |             return result; // lapses automatically to default(T) if TryGetValue returns false
307 |         }
308 | 
309 |         /// <summary>
310 |         /// Look up the value, and return an empty IEnumerable of the specified type if the key is not present.
311 |         /// </summary>
312 |         /// <typeparam name="K">The type of keys.</typeparam>
313 |         /// <typeparam name="V">The type of values.</typeparam>
314 |         /// <param name="theDictionary">The dictionary in which to look up values.</param>
315 |         /// <param name="key">They key to look up.</param>
316 |         /// <returns>The value of type T corresponding to the key if the key is present in the dictionary, otherwise, an empty enumerable of V's.</returns>
317 |         public static IEnumerable<V> GetValueOrEmpty<K, V>(
318 |             this IDictionary<K, IEnumerable<V>> theDictionary,
319 |             K key)
320 |         {
321 |             IEnumerable<V> result;
322 |             var foundP = theDictionary.TryGetValue(key, out result);
323 |             Contract.Assert(foundP == true || result == null); // null is the default for IEnumerable
324 |             var result2 = result ?? Enumerable.Empty<V>();
325 |             return result2;
326 |         }
327 | 
328 |         /// <summary>
329 |         /// Look up the value, and return the specified value if the key is not present.
330 |         /// </summary>
331 |         /// <typeparam name="K">The type of keys.</typeparam>
332 |         /// <typeparam name="V">The type of values.</typeparam>
333 |         /// <param name="theDictionary">The dictionary in which to look up values.</param>
334 |         /// <param name="key">They key to look up.</param>
335 |         /// <param name="specified">The specified value to return if the key is not present.</param>
336 |         /// <returns>The value of type T corresponding to the key if the key is present in the dictionary, otherwise, the specified value of type V.</returns>
337 |         public static V GetValueOrSpecified<K, V>(
338 |             this IDictionary<K, V> theDictionary,
339 |             K key,
340 |             V specified)
341 |             where V : class
342 |         {
343 |             V result;
344 |             var foundP = theDictionary.TryGetValue(key, out result);
345 |             Contract.Assert(foundP == true || result == null);
346 |             var result2 = result ?? specified;
347 |             return result2;
348 |         }
349 | 
350 |         /// <summary>
351 |         /// Look up the value, and return the specified value if the key is not present.
352 |         /// </summary>
353 |         /// <typeparam name="K">The type of keys.</typeparam>
354 |         /// <typeparam name="V">The type of values.</typeparam>
355 |         /// <param name="theDictionary">The dictionary in which to look up values.</param>
356 |         /// <param name="key">They key to look up.</param>
357 |         /// <param name="specified">The specified value to return if the key is not present.</param>
358 |         /// <returns>The value of type T corresponding to the key if the key is present in the dictionary, otherwise, the specified value of type V.</returns>
359 |         public static V GetValueOrSpecifiedValueType<K, V>(
360 |             this IDictionary<K, V> theDictionary,
361 |             K key,
362 |             V specified)
363 |             where V : struct
364 |         {
365 |             V result;
366 |             var foundP = theDictionary.TryGetValue(key, out result);
367 |             Contract.Assert(foundP == true || result.Equals(default(V)));
368 |             return result;
369 |         }
370 | 
371 |         /// <summary>
372 |         /// Increases the tally count for the given key in the dictionary..
373 |         /// </summary>
374 |         /// <typeparam name="K">The type of keys.</typeparam>
375 |         /// <param name="theDictionary">The dictionary in which to tally keys.</param>
376 |         /// <param name="key">The key to tally.</param>
377 |         public static IDictionary<K, long> Tally<K>(
378 |             this IDictionary<K, long> theDictionary,
379 |             K key)
380 |         {
381 |             return theDictionary.AddUnconditionally(
382 |                 key, 
383 |                 theDictionary.GetValueOrDefaultValueType(key) + 1);
384 |         }
385 | 
386 |         /// <summary>
387 |         /// (Overload that creates the dictionary) Increases the tally count for the given key in the dictionary..
388 |         /// </summary>
389 |         /// <typeparam name="K">The type of keys.</typeparam>
390 |         /// <param name="key">The key to tally.</param>
391 |         public static IDictionary<K, long> Tally<K>(
392 |             K key)
393 |         {
394 |             return IDictionary.Create(key, 1L);
395 |         }
396 |     }
397 | }
398 | 


--------------------------------------------------------------------------------
/DotNetExtensions.csproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <PropertyGroup>
 4 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 5 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 6 |     <ProductVersion>8.0.30703</ProductVersion>
 7 |     <SchemaVersion>2.0</SchemaVersion>
 8 |     <ProjectGuid>{929C6B38-22D8-42EC-8D24-03678DFAF228}</ProjectGuid>
 9 |     <OutputType>Library</OutputType>
10 |     <AppDesignerFolder>Properties</AppDesignerFolder>
11 |     <RootNamespace>Monza.DotNetExtensions</RootNamespace>
12 |     <AssemblyName>DotNetExtensions</AssemblyName>
13 |     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
14 |     <FileAlignment>512</FileAlignment>
15 |     <SccProjectName>
16 |     </SccProjectName>
17 |     <SccLocalPath>
18 |     </SccLocalPath>
19 |     <SccAuxPath>
20 |     </SccAuxPath>
21 |     <SccProvider>
22 |     </SccProvider>
23 |     <CodeContractsAssemblyMode>0</CodeContractsAssemblyMode>
24 |   </PropertyGroup>
25 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
26 |     <DebugSymbols>true</DebugSymbols>
27 |     <DebugType>full</DebugType>
28 |     <Optimize>false</Optimize>
29 |     <OutputPath>bin\Debug\</OutputPath>
30 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
31 |     <ErrorReport>prompt</ErrorReport>
32 |     <WarningLevel>4</WarningLevel>
33 |     <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
34 |     <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
35 |     <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
36 |     <CodeContractsRuntimeCallSiteRequires>True</CodeContractsRuntimeCallSiteRequires>
37 |     <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
38 |     <CodeContractsRunCodeAnalysis>True</CodeContractsRunCodeAnalysis>
39 |     <CodeContractsNonNullObligations>True</CodeContractsNonNullObligations>
40 |     <CodeContractsBoundsObligations>True</CodeContractsBoundsObligations>
41 |     <CodeContractsArithmeticObligations>True</CodeContractsArithmeticObligations>
42 |     <CodeContractsEnumObligations>True</CodeContractsEnumObligations>
43 |     <CodeContractsRedundantAssumptions>True</CodeContractsRedundantAssumptions>
44 |     <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
45 |     <CodeContractsShowSquigglies>False</CodeContractsShowSquigglies>
46 |     <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
47 |     <CodeContractsEmitXMLDocs>True</CodeContractsEmitXMLDocs>
48 |     <CodeContractsCustomRewriterAssembly />
49 |     <CodeContractsCustomRewriterClass />
50 |     <CodeContractsLibPaths />
51 |     <CodeContractsExtraRewriteOptions />
52 |     <CodeContractsExtraAnalysisOptions />
53 |     <CodeContractsBaseLineFile />
54 |     <CodeContractsCacheAnalysisResults>False</CodeContractsCacheAnalysisResults>
55 |     <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
56 |     <CodeContractsReferenceAssembly>Build</CodeContractsReferenceAssembly>
57 |     <CodeContractsAnalysisWarningLevel>0</CodeContractsAnalysisWarningLevel>
58 |   </PropertyGroup>
59 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
60 |     <DebugType>pdbonly</DebugType>
61 |     <Optimize>true</Optimize>
62 |     <OutputPath>bin\Release\</OutputPath>
63 |     <DefineConstants>TRACE</DefineConstants>
64 |     <ErrorReport>prompt</ErrorReport>
65 |     <WarningLevel>4</WarningLevel>
66 |   </PropertyGroup>
67 |   <ItemGroup>
68 |     <Reference Include="System" />
69 |     <Reference Include="System.Core" />
70 |     <Reference Include="System.Xml.Linq" />
71 |     <Reference Include="System.Data.DataSetExtensions" />
72 |     <Reference Include="Microsoft.CSharp" />
73 |     <Reference Include="System.Data" />
74 |     <Reference Include="System.Xml" />
75 |   </ItemGroup>
76 |   <ItemGroup>
77 |     <Compile Include="CastExtensions.cs" />
78 |     <Compile Include="DictionaryExtensions.cs" />
79 |     <Compile Include="EnumerableExtensions.cs" />
80 |     <Compile Include="iSynapticSubset\IMaybe.cs" />
81 |     <Compile Include="iSynapticSubset\Maybe.cs" />
82 |     <Compile Include="iSynapticSubset\State.cs" />
83 |     <Compile Include="iSynapticSubset\TrySelector.cs" />
84 |     <Compile Include="iSynapticSubset\Unit.cs" />
85 |     <Compile Include="Numerics.cs" />
86 |     <Compile Include="Properties\AssemblyInfo.cs" />
87 |   </ItemGroup>
88 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
89 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
90 |        Other similar extension points exist, see Microsoft.Common.targets.
91 |   <Target Name="BeforeBuild">
92 |   </Target>
93 |   <Target Name="AfterBuild">
94 |   </Target>
95 |   -->
96 | </Project>


--------------------------------------------------------------------------------
/DotNetExtensions.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 11.00
 3 | # Visual Studio 2010
 4 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DotNetExtensions", "DotNetExtensions.csproj", "{929C6B38-22D8-42EC-8D24-03678DFAF228}"
 5 | EndProject
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DotNetExtensionsTests", "DotNetExtensionsTestProject1\DotNetExtensionsTests.csproj", "{FACE70D1-ED03-498F-95ED-673E514229DE}"
 7 | EndProject
 8 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{60A996A6-0AE6-4C49-94FF-094A3B3A1B61}"
 9 | 	ProjectSection(SolutionItems) = preProject
10 | 		README.md = README.md
11 | 	EndProjectSection
12 | EndProject
13 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Viterbi", "Viterbi\Viterbi.csproj", "{021A5039-3860-49DB-9D6F-B2B8C14497A8}"
14 | EndProject
15 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ViterbiTests", "ViterbiTests\ViterbiTests.csproj", "{CF26536C-4497-4760-914E-4FCA8F57A283}"
16 | EndProject
17 | Global
18 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
19 | 		Debug|Any CPU = Debug|Any CPU
20 | 		Release|Any CPU = Release|Any CPU
21 | 	EndGlobalSection
22 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
23 | 		{929C6B38-22D8-42EC-8D24-03678DFAF228}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
24 | 		{929C6B38-22D8-42EC-8D24-03678DFAF228}.Debug|Any CPU.Build.0 = Debug|Any CPU
25 | 		{929C6B38-22D8-42EC-8D24-03678DFAF228}.Release|Any CPU.ActiveCfg = Release|Any CPU
26 | 		{929C6B38-22D8-42EC-8D24-03678DFAF228}.Release|Any CPU.Build.0 = Release|Any CPU
27 | 		{FACE70D1-ED03-498F-95ED-673E514229DE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
28 | 		{FACE70D1-ED03-498F-95ED-673E514229DE}.Debug|Any CPU.Build.0 = Debug|Any CPU
29 | 		{FACE70D1-ED03-498F-95ED-673E514229DE}.Release|Any CPU.ActiveCfg = Release|Any CPU
30 | 		{FACE70D1-ED03-498F-95ED-673E514229DE}.Release|Any CPU.Build.0 = Release|Any CPU
31 | 		{021A5039-3860-49DB-9D6F-B2B8C14497A8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
32 | 		{021A5039-3860-49DB-9D6F-B2B8C14497A8}.Debug|Any CPU.Build.0 = Debug|Any CPU
33 | 		{021A5039-3860-49DB-9D6F-B2B8C14497A8}.Release|Any CPU.ActiveCfg = Release|Any CPU
34 | 		{021A5039-3860-49DB-9D6F-B2B8C14497A8}.Release|Any CPU.Build.0 = Release|Any CPU
35 | 		{CF26536C-4497-4760-914E-4FCA8F57A283}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
36 | 		{CF26536C-4497-4760-914E-4FCA8F57A283}.Debug|Any CPU.Build.0 = Debug|Any CPU
37 | 		{CF26536C-4497-4760-914E-4FCA8F57A283}.Release|Any CPU.ActiveCfg = Release|Any CPU
38 | 		{CF26536C-4497-4760-914E-4FCA8F57A283}.Release|Any CPU.Build.0 = Release|Any CPU
39 | 	EndGlobalSection
40 | 	GlobalSection(SolutionProperties) = preSolution
41 | 		HideSolutionNode = FALSE
42 | 	EndGlobalSection
43 | EndGlobal
44 | 


--------------------------------------------------------------------------------
/DotNetExtensionsTestProject1/DictionaryExtensionsTests.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Concurrent;
  3 | using System.Text;
  4 | using System.Collections.Generic;
  5 | using System.Linq;
  6 | using Microsoft.VisualStudio.TestTools.UnitTesting;
  7 | using Experimental.DotNetExtensions;
  8 | using System.Collections;
  9 | using System.Diagnostics;
 10 | 
 11 | namespace DotNetExtensionsTestProject1
 12 | {
 13 |     [TestClass()]
 14 |     public class DictionaryExtensionsTests
 15 |     {
 16 |         /// <summary>
 17 |         ///Gets or sets the test context which provides
 18 |         ///information about and functionality for the current test run.
 19 |         ///</summary>
 20 |         public TestContext TestContext { get; set; }
 21 |         public static Dictionary<int, string> TestDictionary;
 22 | 
 23 |         #region Additional test attributes
 24 |         // 
 25 |         //You can use the following additional attributes as you write your tests:
 26 |         //
 27 |         //Use ClassInitialize to run code before running the first test in the class
 28 |         [ClassInitialize()]
 29 |         public static void DictionaryTestClassInitialize(TestContext testContext)
 30 |         {
 31 |             TestDictionary = new Dictionary<int, string>();
 32 |         }
 33 | 
 34 |         //Use ClassCleanup to run code after all tests in a class have run
 35 |         //[ClassCleanup()]
 36 |         //public static void MyClassCleanup()
 37 |         //{
 38 |         //}
 39 |         //
 40 |         //Use TestInitialize to run code before running each test
 41 |         [TestInitialize()]
 42 |         public void DictionaryTestInitialize()
 43 |         {
 44 |             TestDictionary.Clear();
 45 | 
 46 |             TestDictionary[1] = "a";
 47 |             TestDictionary[2] = "b";
 48 |             TestDictionary[3] = "c";
 49 |         }
 50 | 
 51 |         //Use TestCleanup to run code after each test has run
 52 |         //[TestCleanup()]
 53 |         //public void MyTestCleanup()
 54 |         //{
 55 |         //}
 56 |         //
 57 |         #endregion
 58 | 
 59 |         private static void AssertDictionaryInitialized()
 60 |         {
 61 |             Assert.AreEqual(TestDictionary[1], "a");
 62 |             Assert.AreEqual(TestDictionary[2], "b");
 63 |             Assert.AreEqual(TestDictionary[3], "c");
 64 |             Assert.IsFalse(TestDictionary.Values.Contains("d"));
 65 |             Assert.IsFalse(TestDictionary.Values.Contains("e"));
 66 |             Assert.IsFalse(TestDictionary.Values.Contains("f"));
 67 |         }
 68 | 
 69 |         //[TestMethod()]
 70 |         //public void TestAddUnconditionally()
 71 |         //{
 72 |         //    AssertDictionaryInitialized();
 73 | 
 74 |         //    Assert.IsFalse(TestDictionary.AddUnconditionally(5, "e"));
 75 |         //    Assert.IsTrue(TestDictionary.Values.Contains("e"));
 76 |         //    Assert.AreEqual(TestDictionary[5], "e");
 77 | 
 78 |         //    Assert.IsTrue(TestDictionary.AddUnconditionally(5, "f"));
 79 |         //    Assert.IsFalse(TestDictionary.Values.Contains("e"));
 80 |         //    Assert.AreEqual(TestDictionary[5], "f");
 81 |         //}
 82 | 
 83 |         [TestMethod()]
 84 |         public void TestAddConditionally()
 85 |         {
 86 |             AssertDictionaryInitialized();
 87 | 
 88 |             var dict = TestDictionary
 89 |                 .AddConditionally(4, "d")
 90 |                 .AddConditionally(3, "e")
 91 |                 ;
 92 | 
 93 |             Assert.IsNotNull(dict);
 94 |             Assert.ReferenceEquals(dict, TestDictionary);
 95 | 
 96 |             Assert.AreEqual(dict[3], "c");
 97 |             Assert.AreEqual(dict[4], "d");
 98 | 
 99 |             Assert.IsFalse(dict.Values.Contains("e"));
100 | 
101 |             var maybe = TestDictionary.TryGetValue(3);
102 |             Assert.IsTrue(maybe.HasValue);
103 |             Assert.AreEqual(maybe.Value, "c");
104 | 
105 |             maybe = TestDictionary.TryGetValue(5);
106 |             Assert.IsFalse(maybe.HasValue);
107 | 
108 |             dict.Clear();
109 |             Assert.AreEqual(0, dict.Values.Count());
110 |             Assert.AreEqual(0, dict.Keys.Count());
111 | 
112 |             const int range = 1280;
113 |             var kvps = Enumerable
114 |                 .Range(0, range)
115 |                 .Select(i => new KeyValuePair<int, string>(i, Convert.ToChar(i).ToString()))
116 |                 ;
117 | 
118 |             dict = kvps.Aggregate(dict, (d, kvp) => d.AddConditionally(kvp));
119 | 
120 |             Assert.AreEqual(range, dict.Count());
121 | 
122 |             var cc = new CollectionComparer<KeyValuePair<int, string>>();
123 |             Assert.IsTrue(cc.Equals(kvps, dict));
124 | 
125 |             CollectionAssert.AreEquivalent(kvps.ToList(), dict.ToList());
126 | 
127 |             kvps = Enumerable
128 |                 .Range(0, range)
129 |                 .Select(i => new KeyValuePair<int, string>(i, Convert.ToChar(3 * i + 7).ToString()))
130 |                 ;
131 | 
132 |             dict = kvps.Aggregate(dict, (d, kvp) => d.AddConditionally(kvp));
133 | 
134 |             CollectionAssert.AreNotEquivalent(kvps.ToList(), dict.ToList());
135 |         }
136 | 
137 |         [TestMethod()]
138 |         public void TestAddUnConditionally()
139 |         {
140 |             AssertDictionaryInitialized();
141 | 
142 |             var dict = TestDictionary
143 |                 .AddUnconditionally(4, "d")
144 |                 .AddUnconditionally(3, "e")
145 |                 ;
146 | 
147 |             Assert.IsNotNull(dict);
148 |             Assert.ReferenceEquals(dict, TestDictionary);
149 | 
150 |             Assert.AreEqual(dict[3], "e");
151 |             Assert.AreEqual(dict[4], "d");
152 | 
153 |             Assert.IsFalse(dict.Values.Contains("c"));
154 | 
155 |             var maybe = TestDictionary.TryGetValue(3);
156 |             Assert.IsTrue(maybe.HasValue);
157 |             Assert.AreEqual(maybe.Value, "e");
158 | 
159 |             maybe = TestDictionary.TryGetValue(5);
160 |             Assert.IsFalse(maybe.HasValue);
161 | 
162 |             dict.Clear();
163 |             Assert.AreEqual(0, dict.Values.Count());
164 |             Assert.AreEqual(0, dict.Keys.Count());
165 | 
166 |             const int range = 1280;
167 |             var kvps = Enumerable
168 |                 .Range(0, range)
169 |                 .Select(i => new KeyValuePair<int, string>(i, Convert.ToChar(i).ToString()))
170 |                 ;
171 | 
172 |             dict = kvps.Aggregate(dict, (d, kvp) => d.AddUnconditionally(kvp));
173 | 
174 |             Assert.AreEqual(range, dict.Count());
175 | 
176 |             var cc = new CollectionComparer<KeyValuePair<int, string>>();
177 |             Assert.IsTrue(cc.Equals(kvps, dict));
178 | 
179 |             CollectionAssert.AreEquivalent(kvps.ToList(), dict.ToList());
180 | 
181 |             kvps = Enumerable
182 |                 .Range(0, range)
183 |                 .Select(i => new KeyValuePair<int, string>(i, Convert.ToChar(3 * i + 7).ToString()))
184 |                 ;
185 | 
186 |             dict = kvps.Aggregate(dict, (d, kvp) => d.AddUnconditionally(kvp));
187 | 
188 |             CollectionAssert.AreEquivalent(kvps.ToList(), dict.ToList());
189 |         }
190 | 
191 |         [TestMethod()]
192 |         public void TestExPerf()
193 |         {
194 |             const int repetitions = 10000;
195 |             AssertDictionaryInitialized();
196 | 
197 |             TestDictionary = new Dictionary<int, string>();
198 |             var random = new Random();
199 |             var stopwatch = new Stopwatch();
200 |             var kvps = Enumerable
201 |                 .Range(0, repetitions)
202 |                 .Select(_ => random.Next())
203 |                 .Select(i => new KeyValuePair<int, string>(
204 |                     i,
205 |                     i.GetHashCode().ToString()))
206 |                 .ToList()
207 |                 ;
208 | 
209 | 
210 | 
211 |             stopwatch.Start();
212 |             
213 |             
214 |             
215 |             var dict = kvps.Aggregate(
216 |                 TestDictionary as IDictionary<int, string>,
217 |                 (d, kvp) => d.AddUnconditionally(kvp));
218 |             Trace.WriteLine(string.Format(
219 |                 "MONADIC UNCONDITIONAL DICTIONARY COUNT: {0}",
220 |                 dict.Count()));
221 |             var dict1 = dict.ToList();
222 |             var ticks = stopwatch.ElapsedTicks;
223 |             
224 |             
225 |             
226 |             stopwatch.Reset();
227 | 
228 | 
229 | 
230 |             Trace.WriteLine(string.Format(
231 |                 "MONADIC UNCONDITIONAL DICTIONARY PERF: Milliseconds to insert {0} items = {1} monadically",
232 |                 repetitions,
233 |                 Math.Round(ticks / 1.0e4, 3)));
234 | 
235 | 
236 | 
237 |             dict = new Dictionary<int, string>();
238 |             stopwatch.Start();
239 |             
240 |             
241 |             
242 |             foreach (var kvp in kvps)
243 |                 dict[kvp.Key] = kvp.Value;
244 |             Trace.WriteLine(string.Format(
245 |                 "NON-MONADIC UNCONDITIONAL DICTIONARY COUNT: {0}",
246 |                 dict.Count()));
247 |             var dict2 = dict.ToList();
248 |             ticks = stopwatch.ElapsedTicks;
249 | 
250 | 
251 |             
252 |             stopwatch.Reset();
253 | 
254 | 
255 | 
256 |             Trace.WriteLine(string.Format(
257 |                 "NON-MONADIC UNCONDITIONAL DICTIONARY PERF: Milliseconds to insert {0} items = {1} NON-monadically",
258 |                 repetitions,
259 |                 Math.Round(ticks / 1.0e4, 3)));
260 | 
261 | 
262 |             CollectionAssert.AreEquivalent(dict1, dict2);
263 | 
264 | 
265 |             
266 |             dict = new Dictionary<int, string>();
267 |             stopwatch.Start();
268 | 
269 | 
270 | 
271 |             dict = kvps.Aggregate(
272 |                 TestDictionary as IDictionary<int, string>,
273 |                 (d, kvp) => d.AddConditionally(kvp));
274 |             Trace.WriteLine(string.Format(
275 |                 "MONADIC CONDITIONAL DICTIONARY COUNT: {0}",
276 |                 dict.Count()));
277 |             dict1 = dict.ToList();
278 |             ticks = stopwatch.ElapsedTicks;
279 | 
280 | 
281 | 
282 |             stopwatch.Reset();
283 | 
284 | 
285 | 
286 |             Trace.WriteLine(string.Format(
287 |                 "MONADIC CONDITIONAL DICTIONARY PERF: Milliseconds to insert {0} items = {1} monadically",
288 |                 repetitions,
289 |                 Math.Round(ticks / 1.0e4, 3)));
290 | 
291 | 
292 | 
293 |             dict = new Dictionary<int, string>();
294 |             stopwatch.Start();
295 | 
296 | 
297 | 
298 |             foreach (var kvp in kvps)
299 |             {
300 |                 string value;
301 |                 if (!dict.TryGetValue(kvp.Key, out value))
302 |                     dict[kvp.Key] = kvp.Value;
303 |             }
304 |             Trace.WriteLine(string.Format(
305 |                 "NON-MONADIC CONDITIONAL DICTIONARY COUNT: {0}",
306 |                 dict.Count()));
307 |             dict2 = dict.ToList();
308 |             ticks = stopwatch.ElapsedTicks;
309 | 
310 |             
311 | 
312 |             stopwatch.Reset();
313 | 
314 | 
315 | 
316 |             Trace.WriteLine(string.Format(
317 |                 "NON-MONADIC CONDITIONAL DICTIONARY PERF: Milliseconds to insert {0} items = {1} NON-monadically",
318 |                 repetitions,
319 |                 Math.Round(ticks / 1.0e4, 3)));
320 | 
321 | 
322 | 
323 |             CollectionAssert.AreEquivalent(dict1, dict2);
324 |         }
325 |     }
326 | 
327 |     public class CollectionComparer<T> : IEqualityComparer<IEnumerable<T>>
328 |     {
329 |         public bool Equals(IEnumerable<T> first, IEnumerable<T> second)
330 |         {
331 |             if ((first == null) != (second == null))
332 |                 return false;
333 |             // At this point, either both null or both not null.
334 |             if (!object.ReferenceEquals(first, second) && (first != null))
335 |             {
336 |                 // At this point, both not null.
337 |                 if (first.Count() != second.Count())
338 |                     return false;
339 |                 if ((first.Count() != 0) && HaveMismatchedElement(first, second))
340 |                     return false;
341 |             }
342 |             return true;
343 |         }
344 | 
345 |         private static bool HaveMismatchedElement(IEnumerable<T> first, IEnumerable<T> second)
346 |         {
347 |             int firstCount;
348 |             int secondCount;
349 | 
350 |             var firstTallies = GetElementTally(first, out firstCount);
351 |             var secondTallies = GetElementTally(second, out secondCount);
352 |             // Number of nulls doesn't match
353 |             if (firstCount != secondCount)
354 |                 return true;
355 | 
356 |             foreach (var kvp in firstTallies)
357 |             {
358 |                 firstCount = kvp.Value;
359 |                 secondTallies.TryGetValue(kvp.Key, out secondCount);
360 |                 // Some element tally doesn't match
361 |                 if (firstCount != secondCount)
362 |                     return true;
363 |             }
364 |             // All element tallies match
365 |             return false;
366 |         }
367 |         private static Dictionary<T, int> GetElementTally(
368 |             IEnumerable<T> enumerable,
369 |             out int nullTally)
370 |         {
371 |             var dictionary = new Dictionary<T, int>();
372 |             nullTally = 0;
373 |             foreach (T element in enumerable)
374 |             {
375 |                 if (element == null)
376 |                 {
377 |                     nullTally++;
378 |                 }
379 |                 else
380 |                 {
381 |                     int num;
382 |                     dictionary.TryGetValue(element, out num);
383 |                     num++;
384 |                     dictionary[element] = num;
385 |                 }
386 |             }
387 |             return dictionary;
388 |         }
389 |         public int GetHashCode(IEnumerable<T> enumerable)
390 |         {
391 |             int hash = 17;
392 |             foreach (T val in enumerable.OrderBy(x => x))
393 |                 hash = hash * 23 + val.GetHashCode();
394 |             return hash;
395 |         }
396 |     }
397 | }
398 | 
399 | 


--------------------------------------------------------------------------------
/DotNetExtensionsTestProject1/DotNetExtensionsTests.csproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <PropertyGroup>
 4 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 5 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 6 |     <ProductVersion>
 7 |     </ProductVersion>
 8 |     <SchemaVersion>2.0</SchemaVersion>
 9 |     <ProjectGuid>{FACE70D1-ED03-498F-95ED-673E514229DE}</ProjectGuid>
10 |     <OutputType>Library</OutputType>
11 |     <AppDesignerFolder>Properties</AppDesignerFolder>
12 |     <RootNamespace>DotNetExtensionsTestProject1</RootNamespace>
13 |     <AssemblyName>DotNetExtensionsTestProject1</AssemblyName>
14 |     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
15 |     <FileAlignment>512</FileAlignment>
16 |     <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
17 |     <SccProjectName>
18 |     </SccProjectName>
19 |     <SccLocalPath>
20 |     </SccLocalPath>
21 |     <SccAuxPath>
22 |     </SccAuxPath>
23 |     <SccProvider>
24 |     </SccProvider>
25 |   </PropertyGroup>
26 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
27 |     <DebugSymbols>true</DebugSymbols>
28 |     <DebugType>full</DebugType>
29 |     <Optimize>false</Optimize>
30 |     <OutputPath>bin\Debug\</OutputPath>
31 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
32 |     <ErrorReport>prompt</ErrorReport>
33 |     <WarningLevel>4</WarningLevel>
34 |   </PropertyGroup>
35 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
36 |     <DebugType>pdbonly</DebugType>
37 |     <Optimize>true</Optimize>
38 |     <OutputPath>bin\Release\</OutputPath>
39 |     <DefineConstants>TRACE</DefineConstants>
40 |     <ErrorReport>prompt</ErrorReport>
41 |     <WarningLevel>4</WarningLevel>
42 |   </PropertyGroup>
43 |   <ItemGroup>
44 |     <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
45 |     <Reference Include="System" />
46 |     <Reference Include="System.Core">
47 |       <RequiredTargetFramework>3.5</RequiredTargetFramework>
48 |     </Reference>
49 |   </ItemGroup>
50 |   <ItemGroup>
51 |     <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
52 |       <Visible>False</Visible>
53 |     </CodeAnalysisDependentAssemblyPaths>
54 |   </ItemGroup>
55 |   <ItemGroup>
56 |     <Compile Include="Properties\AssemblyInfo.cs" />
57 |     <Compile Include="DictionaryExtensionsTests.cs" />
58 |   </ItemGroup>
59 |   <ItemGroup>
60 |     <ProjectReference Include="..\DotNetExtensions.csproj">
61 |       <Project>{929C6B38-22D8-42EC-8D24-03678DFAF228}</Project>
62 |       <Name>DotNetExtensions</Name>
63 |     </ProjectReference>
64 |   </ItemGroup>
65 |   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
66 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
67 |        Other similar extension points exist, see Microsoft.Common.targets.
68 |   <Target Name="BeforeBuild">
69 |   </Target>
70 |   <Target Name="AfterBuild">
71 |   </Target>
72 |   -->
73 | </Project>


--------------------------------------------------------------------------------
/DotNetExtensionsTestProject1/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following 
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("DotNetExtensionsTestProject1")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("Microsoft")]
12 | [assembly: AssemblyProduct("DotNetExtensionsTestProject1")]
13 | [assembly: AssemblyCopyright("Copyright © Microsoft 2011")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible 
18 | // to COM components.  If you need to access a type in this assembly from 
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("f3f22c33-ec3f-4ec1-8021-3bfa6c7e8b62")]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version 
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers 
33 | // by using the '*' as shown below:
34 | [assembly: AssemblyVersion("1.0.0.0")]
35 | [assembly: AssemblyFileVersion("1.0.0.0")]
36 | 


--------------------------------------------------------------------------------
/EnumerableExtensions.cs:
--------------------------------------------------------------------------------
  1 | // The MIT License
  2 | 
  3 | // Portions Copyright (c) 2011 Jordan E. Terrell, licensed to 
  4 | // Microsoft Corporation under the MIT license (copied below).
  5 | // 
  6 | // Portions Copyright (c) 2011 Microsoft Corporation
  7 | // 
  8 | // Portions adapted from http://northhorizon.net/ under the 
  9 | // Creative Commons Attribution license 
 10 | // http://creativecommons.org/licenses/by/3.0/us/)
 11 | 
 12 | // Permission is hereby granted, free of charge, to any person obtaining
 13 | // a copy of this software and associated documentation files (the
 14 | // "Software"), to deal in the Software without restriction, including
 15 | // without limitation the rights to use, copy, modify, merge, publish,
 16 | // distribute, sublicense, and/or sell copies of the Software, and to
 17 | // permit persons to whom the Software is furnished to do so, subject to
 18 | // the following conditions:
 19 | 
 20 | // The above copyright notice and this permission notice shall be
 21 | // included in all copies or substantial portions of the Software.
 22 | 
 23 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 24 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 25 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 26 | // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 27 | // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 28 | // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 29 | // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 30 | using System;
 31 | using System.Collections.Generic;
 32 | using System.Diagnostics.Contracts;
 33 | using System.Linq;
 34 | 
 35 | namespace Experimental.DotNetExtensions
 36 | {
 37 |     /// <summary>
 38 |     /// Provides extension methods for <see cref="IEnumerable{T}"/> and <see cref="IEnumerable"/>.
 39 |     /// </summary>
 40 |     public static class IEnumerable
 41 |     {
 42 |         /// <summary>
 43 |         /// The standard monadic "Return" operation.
 44 |         /// </summary>
 45 |         /// <typeparam name="T">The type of the thing to lift into the monad.</typeparam>
 46 |         /// <param name="singleValue">The sone value to lift into the monad.</param>
 47 |         /// <returns>An IEnumerable containing a single item of type T.</returns>
 48 |         public static IEnumerable<T> Return<T>(this T singleValue)
 49 |         {
 50 |             return new[] { singleValue } as IEnumerable<T>;
 51 |         }
 52 | 
 53 |         /// <summary>
 54 |         /// Constructs the outer product (outer join) of two IEnumerables, as an IEnumerable of Tuples.
 55 |         /// </summary>
 56 |         /// <param name="these">The first IEnumerable.</param>
 57 |         /// <param name="those">The second IEnumerable.</param>
 58 |         /// <returns>The IEnumerable of pairs (as Tuples) of the inputs.</returns>
 59 |         public static IEnumerable<Tuple<A, B>> Outer<A, B>(
 60 |             this IEnumerable<A> these,
 61 |             IEnumerable<B> those)
 62 |         {
 63 |             Contract.Requires(these != null);
 64 |             Contract.Requires(those != null);
 65 | 
 66 |             return from a in these
 67 |                    from b in those
 68 |                    select Tuple.Create(a, b);
 69 |         }
 70 | 
 71 |         /// <summary>
 72 |         /// Gets the input argument that produces the maximum value of the specified function.
 73 |         /// </summary>
 74 |         /// <typeparam name="A">The type of items in the collection.</typeparam>
 75 |         /// <typeparam name="T">The type of the value yielded from the specified function.</typeparam>
 76 |         /// <param name="collection">The target collection.</param>
 77 |         /// <param name="function">The function used to produce values.</param>
 78 |         /// <returns>The argument that produces the highest value.</returns>
 79 |         public static A ArgMax<A, V>(
 80 |             this IEnumerable<A> collection,
 81 |             Func<A, V> function)
 82 |             where V : IComparable<V>
 83 |         {
 84 |             Contract.Requires(collection != null);
 85 |             Contract.Requires(function != null);
 86 |             return ArgComp(collection, function, GreaterThan);
 87 |         }
 88 | 
 89 |         private static bool GreaterThan<A>(A first, A second) where A : IComparable<A>
 90 |         {
 91 |             return first.CompareTo(second) > 0;
 92 |         }
 93 | 
 94 |         /// <summary>
 95 |         /// Gets the intput argument that produces the minimum value of the specified function.
 96 |         /// </summary>
 97 |         /// <typeparam name="A">The type of items in the collection.</typeparam>
 98 |         /// <typeparam name="T">The type of the value yielded from the specified function.</typeparam>
 99 |         /// <param name="collection">The target collection.</param>
100 |         /// <param name="function">The function used to produce values.</param>
101 |         /// <returns>The argument that produces the least value.</returns>
102 |         public static A ArgMin<A, V>(
103 |             this IEnumerable<A> collection,
104 |             Func<A, V> function)
105 |             where V : IComparable<V>
106 |         {
107 |             Contract.Requires(collection != null);
108 |             Contract.Requires(function != null);
109 |             return ArgComp(collection, function, LessThan);
110 |         }
111 | 
112 |         private static bool LessThan<A>(A first, A second) where A : IComparable<A>
113 |         {
114 |             return first.CompareTo(second) < 0;
115 |         }
116 | 
117 |         private static A ArgComp<A, V>(
118 |             IEnumerable<A> collection,
119 |             Func<A, V> function,
120 |             Func<V, V, bool> accept)
121 | 
122 |             where V : IComparable<V>
123 |         {
124 |             Contract.Requires(collection != null);
125 |             Contract.Requires(function != null);
126 |             Contract.Requires(accept != null);
127 | 
128 |             var isSet = false;
129 |             var maxArg = default(A);
130 |             var extremeValue = default(V);
131 | 
132 |             foreach (var item in collection)
133 |             {
134 |                 var value = function(item);
135 |                 if (!isSet || accept(value, extremeValue))
136 |                 {
137 |                     maxArg = item;
138 |                     extremeValue = value;
139 |                     isSet = true;
140 |                 }
141 |             }
142 | 
143 |             return maxArg;
144 |         }
145 | 
146 |         /// <summary>
147 |         /// Encapsulates returned argument-and-value pairs from ArgAndMax and ArgAndMin.
148 |         /// </summary>
149 |         /// <typeparam name="A">The argument at which the IEnumerable has its extreme value.</typeparam>
150 |         /// <typeparam name="T">The extreme value.</typeparam>
151 |         public class ArgumentValuePair<A, V>
152 |         {
153 |             public A Argument { get; set; }
154 |             public V Value { get; set; }
155 |         }
156 | 
157 |         /// <summary>
158 |         /// Gets the argument that produces the maximum value and the maximum value produced by the specified function.
159 |         /// </summary>
160 |         /// <typeparam name="A">The type of items in the collection.</typeparam>
161 |         /// <typeparam name="T">The type of the value yielded from the specified function.</typeparam>
162 |         /// <param name="collection">The target collection.</param>
163 |         /// <param name="function">The function used to produce values.</param>
164 |         /// <returns>Instance of an anonymous type with properties "Argument" and "Value" for the argument producing the maximum value and the minimum value.</returns>
165 |         public static ArgumentValuePair<A, V> ArgAndMax<A, V>(
166 |             this IEnumerable<A> collection,
167 |             Func<A, V> function)
168 |             where V : IComparable<V>
169 |         {
170 |             Contract.Requires(collection != null);
171 |             Contract.Requires(function != null);
172 | 
173 |             return ArgAndComp(collection, function, GreaterThan);
174 |         }
175 | 
176 |         /// <summary>
177 |         /// Gets the argument that produces the minimum value and the minimum value produced by the specified function.
178 |         /// </summary>
179 |         /// <typeparam name="A">The type of items in the collection.</typeparam>
180 |         /// <typeparam name="T">The type of the value yielded from the specified function.</typeparam>
181 |         /// <param name="collection">The target collection.</param>
182 |         /// <param name="function">The function used to produce values.</param>
183 |         /// <returns>Instance of a dynamic type with properties "Argument" and "Value" for the argument producing the minimum value and the minimum value.</returns>
184 |         public static ArgumentValuePair<A, V> ArgAndMin<A, V>(
185 |             this IEnumerable<A> collection,
186 |             Func<A, V> function)
187 |             where V : IComparable<V>
188 |         {
189 |             Contract.Requires(collection != null);
190 |             Contract.Requires(function != null);
191 | 
192 |             return ArgAndComp(collection, function, LessThan);
193 |         }
194 | 
195 |         private static ArgumentValuePair<A, V> ArgAndComp<A, V>(
196 |             IEnumerable<A> collection,
197 |             Func<A, V> function,
198 |             Func<V, V, bool> accept)
199 |             where V : IComparable<V>
200 |         {
201 |             Contract.Requires(collection != null);
202 |             Contract.Requires(function != null);
203 |             Contract.Requires(accept != null);
204 | 
205 |             var isSet = false;
206 |             var maxArg = default(A);
207 |             var extremeValue = default(V);
208 | 
209 |             foreach (var item in collection)
210 |             {
211 |                 var value = function(item);
212 |                 if (!isSet || accept(value, extremeValue))
213 |                 {
214 |                     maxArg = item;
215 |                     extremeValue = value;
216 |                     isSet = true;
217 |                 }
218 |             }
219 | 
220 |             return new ArgumentValuePair<A, V> { Argument = maxArg, Value = extremeValue };
221 |         }
222 | 
223 |         /// <summary>
224 |         /// Perform an action for side effect pairwise on elements of a pair of IEnumerables.
225 |         /// </summary>
226 |         /// <typeparam name="T">The type of elements in the first IEnumerable.</typeparam>
227 |         /// <typeparam name="U">The type of elements in the second IEnumerable.</typeparam>
228 |         /// <param name="first">The first IEnumerable.</param>
229 |         /// <param name="second">The second IEnumerable.</param>
230 |         /// <param name="action">The action to perform on pairs of elements.</param>
231 |         public static void ZipDo<T, U>(
232 |             this IEnumerable<T> first,
233 |             IEnumerable<U> second,
234 |             Action<T, U> action)
235 |         {
236 |             Contract.Requires(first != null);
237 |             Contract.Requires(second != null);
238 |             Contract.Requires(action != null);
239 | 
240 |             using (IEnumerator<T> firstEnumerator = first.GetEnumerator())
241 |             using (IEnumerator<U> secondEnumerator = second.GetEnumerator())
242 |                 while (firstEnumerator.MoveNext() && secondEnumerator.MoveNext())
243 |                     action(firstEnumerator.Current, secondEnumerator.Current);
244 |         }
245 | 
246 |         /// <summary>
247 |         /// Perform an action for side effect pairwise on adjacent members of an IEnumerable.
248 |         /// </summary>
249 |         /// <typeparam name="T">The type of elements in the input enumerable.</typeparam>
250 |         /// <param name="enumerable">The input enumerable.</param>
251 |         /// <param name="action">The action to perform on pairs of adjacent elements.</param>
252 |         public static IEnumerable<T> PairwiseDo<T>(
253 |             this IEnumerable<T> enumerable,
254 |             Action<T, T> action)
255 |         {
256 |             Contract.Requires(enumerable != null);
257 |             Contract.Requires(action != null);
258 |             Contract.Requires(enumerable.First() != null);
259 | 
260 |             enumerable.ZipDo(enumerable.Skip(1), action);
261 | 
262 |             return enumerable;
263 |         }
264 | 
265 |         /// <summary>
266 |         /// Map a binary function over all adjacent pairs in the input enumerable.
267 |         /// </summary>
268 |         /// <typeparam name="T">The type of elements in the input enumerable.</typeparam>
269 |         /// <typeparam name="U">The type of element in the returned enumerable.</typeparam>
270 |         /// <param name="enumerable">The input enumerable.</param>
271 |         /// <param name="resultSelector">The function to map.</param>
272 |         /// <returns>An enumerable of results of mapping the function over the input enumerable, two adjacent elements at a time.</returns>
273 |         public static IEnumerable<U> Pairwise<T, U>(
274 |             this IEnumerable<T> enumerable,
275 |             Func<T, T, U> resultSelector)
276 |         {
277 |             Contract.Requires(enumerable != null);
278 |             Contract.Requires(resultSelector != null);
279 |             Contract.Requires(enumerable.First() != null);
280 | 
281 |             return enumerable.Zip(enumerable.Skip(1), resultSelector);
282 |         }
283 |     }
284 | }
285 | 


--------------------------------------------------------------------------------
/Numerics.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text;
  5 | using System.Diagnostics.Contracts;
  6 | using Experimental.DotNetExtensions.iSynaptic;
  7 | 
  8 | namespace Experimental.DotNetExtensions
  9 | {
 10 |     public struct DoubleComponents
 11 |     {
 12 |         public double Datum { get; set; }
 13 |         public bool IsNaN { get; set; }
 14 |         public bool Negative { get; set; }
 15 |         public int MathematicalBase2Exponent { get; set; }
 16 |         public long MathematicalBase2Mantissa { get; set; }
 17 |         public int RawExponentInt { get; set; }
 18 |         public long RawMantissaLong { get; set; }
 19 |         // TODO: Memoize these
 20 |         public long FloorLog10 { get { return Log10.Floor(); } }
 21 |         public double FracLog10 { get { return Log10 - FloorLog10; } }
 22 |         public double Log10 { get { return Datum.Log10(); } }
 23 |         public byte[] ExponentBits { get { return BitConverter.GetBytes(RawExponentInt); } }
 24 |         public byte[] MantissaBits { get { return BitConverter.GetBytes(RawMantissaLong); } }
 25 |     }
 26 |     /// <summary>
 27 |     /// Numerical routines.
 28 |     /// </summary>
 29 |     public static class Numerics
 30 |     {
 31 |         public static double Log10(this double d) { return Math.Log10(d); }
 32 |         public static double Exp10(this double d) { return Math.Pow(10d, d); }
 33 |         public static double LogB(this double d, double @base) { return Math.Log(d, @base); }
 34 |         public static double Log(this double d) { return Math.Log(d); }
 35 |         public static double Exp(this double d) { return Math.Exp(d); }
 36 |         public static double ExpB(this double d, double @base) { return Math.Pow(@base, d); }
 37 |         public static double Pow(this double d, double exponent) { return Math.Pow(d, exponent); }
 38 |         public static long Floor(this double d) { return ((long)(Math.Floor(d))); }
 39 |         public static long Ceiling(this double d) { return ((long)(Math.Ceiling(d))); }
 40 |         public static double DFloor(this double d) { return ((long)(Math.Floor(d))); }
 41 |         public static double DCeiling(this double d) { return ((long)(Math.Ceiling(d))); }
 42 |         public static double Round(this double d, int digits = 4) { return Math.Round(d, digits); }
 43 | 
 44 |         public static DoubleComponents Decompose(this double d)
 45 |         {
 46 |             // See http://msdn.microsoft.com/en-us/library/aa691146(VS.71).aspx 
 47 |             // and Steve Hollasch's http://steve.hollasch.net/cgindex/coding/ieeefloat.html
 48 |             // and PremK's http://blogs.msdn.com/b/premk/archive/2006/02/25/539198.aspx 
 49 | 
 50 |             var result = new DoubleComponents { Datum = d };
 51 | 
 52 |             long bits = BitConverter.DoubleToInt64Bits(d);
 53 |             bool fNegative = (bits < 0);
 54 |             int exponent = (int)((bits >> 52) & 0x7ffL);
 55 |             long mantissa = (bits & 0xfffffffffffffL);
 56 | 
 57 |             result.Negative = fNegative;
 58 |             result.RawExponentInt = exponent;
 59 |             result.RawMantissaLong = mantissa;
 60 | 
 61 |             if (exponent == 0x7ffL && mantissa != 0)
 62 |             {
 63 |                 Contract.Assert(double.IsNaN(d));
 64 | 
 65 |                 // The number is an NaN. Client must interpret.
 66 |                 result.IsNaN = true;
 67 |                 return result;
 68 |             }
 69 | 
 70 |             // The first bit of the mathematical mantissaBits is always 1, and it is not
 71 |             // represented in the stored mantissaBits bits. The following logic accounts for
 72 |             // this and restores the mantissaBits to its mathematical value.
 73 | 
 74 |             if (exponent == 0)
 75 |             {
 76 |                 if (mantissa == 0)
 77 |                 {
 78 |                     // Returning either +0 or -0.
 79 |                     return result;
 80 |                 }
 81 |                 // Denormalized: A fool-proof detector for denormals is a zero exponentBits. 
 82 |                 // Mantissae for denormals do not have an assumed leading 1-bit. Bump the 
 83 |                 // exponentBits by one so that when we re-bias it by -1023, we have actually 
 84 |                 // brought it back down by -1022, the way it should be. This increment merges 
 85 |                 // the logic for normals and denormals.
 86 |                 exponent++;
 87 |             }
 88 |             else
 89 |             {
 90 |                 // Normalized: radix point (the binary point) is after the first non-zero digit (bit). 
 91 |                 // Or-in the *assumed* leading 1 bit to restore the mathematical mantissaBits.
 92 |                 mantissa = mantissa | (1L << 52);
 93 |             }
 94 | 
 95 |             // Re-bias the exponentBits by the IEEE 1023, which treats the mathematical mantissaBits
 96 |             // as a pure fraction, minus another 52, because we treat the mathematical mantissaBits
 97 |             // as a pure integer.
 98 |             exponent -= 1075;
 99 | 
100 |             // Produce form with lowest possible whole-number mantissaBits.
101 |             while ((mantissa & 1) == 0)
102 |             {
103 |                 mantissa >>= 1;
104 |                 exponent++;
105 |             }
106 | 
107 |             result.MathematicalBase2Exponent = exponent;
108 |             result.MathematicalBase2Mantissa = mantissa;
109 |             return result;
110 |         }
111 | 
112 |         /// <summary>
113 |         /// Compares two doubles for nearness in the absolute value within a given delta, also a double. Not realiable for infinities, epsilon, max_value, min_value, and NaNs.
114 |         /// </summary>
115 |         /// <param name="d1">The first double.</param>
116 |         /// <param name="d2">The second double.</param>
117 |         /// <param name="delta">The allowable absolute difference.</param>
118 |         /// <returns></returns>
119 |         public static bool DoublesWithinAbsoluteDifference(double d1, double d2, double delta)
120 |         {
121 |             return (Math.Abs(d1 - d2) <= Math.Abs(delta));
122 |         }
123 | 
124 |         /// <summary>
125 |         /// Return the bits of a double as a twos-complement long integer. IEEE 745 doubles are 
126 |         /// lexicographically ordered in this representation.
127 |         /// </summary>
128 |         /// <param name="d">The double to convert.</param>
129 |         /// <returns>A long containing the bits of the double in twos-complement.</returns>
130 |         private static long TwosComplementBits(double d)
131 |         {
132 |             long bits = BitConverter.DoubleToInt64Bits(d);
133 |             // Convert to 2-s complement, which are lexicographically ordered.
134 |             if (bits < 0)
135 |                 bits = unchecked((long)(0x8000000000000000 - (ulong)bits));
136 |             return bits;
137 |         }
138 | 
139 |         /// <summary>
140 |         /// Returns the number of IEEE 754 double-precision values separating a pair of doubles. Adjacent doubles
141 |         /// will have a quanta-difference of 1. Returns -1L if either number is NaN. Reports that double.MaxValue
142 |         /// is adjacent to double.PositiveInfinity and likewise for double.MinValue and double.NegativeInfinity.
143 |         /// </summary>
144 |         /// <param name="d1">The first double to compare.</param>
145 |         /// <param name="d2">The second double to compare.</param>
146 |         /// <returns>The number of IEEE 745 doubles separating the pair.</returns>
147 |         public static long LexicographicQuantaDifference(double d1, double d2)
148 |         {
149 |             if (double.IsNaN(d1) || double.IsNaN(d2))
150 |                 return -1L;
151 | 
152 |             // See Bruce Dawson's http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm
153 |             // The major limitation of this technique is that double.MaxValue and double.PostiveInfinity will 
154 |             // report almost equal. See the paper for mitigations.
155 | 
156 |             // Extract bits from the doubles.
157 |             long bits1 = TwosComplementBits(d1);
158 |             long bits2 = TwosComplementBits(d2);
159 | 
160 |             long diff = bits1 - bits2;
161 |             if (diff < 0)
162 |                 diff = -diff;
163 | 
164 |             return diff;
165 |         }
166 | 
167 |         /// <summary>
168 |         /// Compare doubles for equality within a given number of possible discrete double-precision values. 
169 |         /// Produces false if either number is NaN. Reports that double.MaxValue is almost equal to 
170 |         /// double.PositiveInfinity; likewise for double.MinValue and double.NegativeInfinity.
171 |         /// </summary>
172 |         /// <param name="d1">The first double.</param>
173 |         /// <param name="d2">The second double.</param>
174 |         /// <param name="nQuanta">The number of discrete double-precision values permitted between d1 and d2. Must be >= 0.</param>
175 |         /// <returns></returns>
176 |         public static bool DoublesNearlyEqual(double d1, double d2, int nQuanta)
177 |         {
178 |             Contract.Assert(nQuanta >= 0, "nUnits");
179 | 
180 |             if (double.IsNaN(d1) || double.IsNaN(d2))
181 |                 return false;
182 | 
183 |             return LexicographicQuantaDifference(d1, d2) <= nQuanta;
184 |         }
185 |     }
186 | }
187 | 


--------------------------------------------------------------------------------
/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following 
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("Experimental.DotNetExtensions")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("Microsoft")]
12 | [assembly: AssemblyProduct("Experimental.DotNetExtensions")]
13 | [assembly: AssemblyCopyright("Copyright © Microsoft 2011")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible 
18 | // to COM components.  If you need to access a type in this assembly from 
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("05ea01b1-14e9-4dbe-be76-fbf1a879fb3e")]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version 
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers 
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("1.0.0.0")]
36 | [assembly: AssemblyFileVersion("1.0.0.0")]
37 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | This repository contains some dot net extensions to the dictionary type,
 2 | some numerical convenience functions, a couple of combinators for ArgMax.
 3 | 
 4 | People to whom I am indebted are acknowledge in comments in the code, but
 5 | include Jordan E. Terrell (see his extensive iSynaptic project in GitHub),
 6 | and Daniel Moore via northhorizon.net. 
 7 | 
 8 | Licenses invoked include the MIT license and the Creative-Commons 
 9 | Attribution 3.0 United States License.
10 | 
11 | // The MIT License
12 | 
13 | // Portions Copyright (c) 2011 Jordan E. Terrell, licensed to 
14 | // Microsoft Corporation under the MIT license (copied below).
15 | // 
16 | // Portions Copyright (c) 2011 Microsoft Corporation
17 | // 
18 | // Portions adapted from http://northhorizon.net/ under the 
19 | // Creative Commons Attribution license 
20 | // http://creativecommons.org/licenses/by/3.0/us/)
21 | 
22 | // Permission is hereby granted, free of charge, to any person obtaining
23 | // a copy of this software and associated documentation files (the
24 | // "Software"), to deal in the Software without restriction, including
25 | // without limitation the rights to use, copy, modify, merge, publish,
26 | // distribute, sublicense, and/or sell copies of the Software, and to
27 | // permit persons to whom the Software is furnished to do so, subject to
28 | // the following conditions:
29 | 
30 | // The above copyright notice and this permission notice shall be
31 | // included in all copies or substantial portions of the Software.
32 | 
33 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
34 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
35 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
36 | // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
37 | // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
38 | // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
39 | // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/Viterbi/FunctionBasedViterbi.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Diagnostics;
  4 | using System.Diagnostics.Contracts;
  5 | using Experimental.DotNetExtensions;
  6 | 
  7 | namespace Experimental.MachineLearning.Viterbi
  8 | {
  9 |     // TODO: write contract reference assemblies
 10 | 
 11 |     // TODO: optimize to only call probability functions for domain
 12 |     // values guaranteed to return non-zero probabilities
 13 | 
 14 |     /// <summary>
 15 |     /// A reactive type of Viterbi algorithm (
 16 |     /// http://en.wikipedia.org/wiki/Viterbi_algorithm ), suitable for
 17 |     /// on-line or off-line application.  Requires user-supplied
 18 |     /// functions to express the model (state-to-state transition
 19 |     /// probabilities and state-to-observation probabilities)
 20 |     /// </summary>
 21 |     /// <typeparam name="S">The type of states.</typeparam>
 22 |     /// <typeparam name="O">The type of observations.</typeparam>
 23 |     public class FunctionBasedDoubleViterbi<O, S> : IObserver<Tuple<O, IEnumerable<S>>>
 24 |     {
 25 |         /// <summary>
 26 |         /// The TargetStates are the states the system might transition TO in response to an observation.
 27 |         /// </summary>
 28 |         private IEnumerable<S> TargetStates { get; set; }
 29 | 
 30 |         /// <summary>
 31 |         /// The SourceStates are the states the system might transition FROM to EMIT an observation.
 32 |         /// </summary>
 33 |         private IEnumerable<S> SourceStates { get; set; }
 34 | 
 35 |         /// <summary>
 36 |         /// Function that computes probabilities of occurrence of the initial states; for bootstrapping the model.
 37 |         /// </summary>
 38 |         public Func<S, double> StartingProbabilities { get; private set; }
 39 | 
 40 |         /// <summary>
 41 |         /// Transition probabilities from state-to-state; part of the Hidden Markov Model.
 42 |         /// </summary>
 43 |         public Func<S, S, double> TransitionProbabilities { get; private set; }
 44 | 
 45 |         /// <summary>
 46 |         /// Probabilities of observing outcome (observation) O given
 47 |         /// that the system is in state S; part of the Hidden Markov
 48 |         /// Model.
 49 |         /// </summary>
 50 |         public Func<S, O, double> EmissionProbabilities { get; private set; }
 51 | 
 52 |         /// <summary>
 53 |         /// After the current observation is processed, _V.Last()
 54 |         /// contains the probabilities of the most probable paths
 55 |         /// leading to each state.  Each element of _V is a map from
 56 |         /// state to probability of most-probable-path.  _V keeps the
 57 |         /// entire history of such probability maps.
 58 |         /// </summary>
 59 |         private List<Dictionary<S, double>> _V;
 60 | 
 61 |         /// <summary>
 62 |         /// At any time t and for any state s, V[t][s] is the
 63 |         /// probability of the most probable path ending in state s.
 64 |         /// The times are implicitly 0, 1, ...; that is, the indices
 65 |         /// of the IEnumerable.
 66 |         /// </summary>
 67 |         public IEnumerable<Dictionary<S, double>> V { get { return _V; } }
 68 | 
 69 |         /// <summary>
 70 |         /// For any state, the most probable path through all prior
 71 |         /// states leading to that state, given all the observations
 72 |         /// seen so far.  "Path" only keeps the LAST map from state to
 73 |         /// list of states, unlike V, which keeps the entire history
 74 |         /// of maps from states to probabilities of
 75 |         /// most-probable-paths.
 76 |         /// </summary>
 77 |         public Dictionary<S, List<S>> Path { get; private set; }
 78 | 
 79 |         /// <summary>
 80 |         /// The constructor requires functions for computing probabilities. 
 81 |         /// </summary>
 82 |         /// <param name="startingProbabilities">Initial probabilities, one for each state.</param>
 83 |         /// <param name="transitionProbabilities">Probabilities for transition from a state to any other state.</param>
 84 |         /// <param name="emissionProbabilities">Probabilities of seeing observation O given state S.</param>
 85 |         public FunctionBasedDoubleViterbi
 86 |         (
 87 |             Func<S, double> startingProbabilities,
 88 |             Func<S, S, double> transitionProbabilities,
 89 |             Func<S, O, double> emissionProbabilities)
 90 |         {
 91 |             Contract.Requires(startingProbabilities != null);
 92 |             Contract.Requires(transitionProbabilities != null);
 93 |             Contract.Requires(emissionProbabilities != null);
 94 | 
 95 |             // TODO: Require that probabilities sum APPROXIMATELY to one. 
 96 | 
 97 |             StartingProbabilities = startingProbabilities;
 98 |             TransitionProbabilities = transitionProbabilities;
 99 |             EmissionProbabilities = emissionProbabilities;
100 |         }
101 | 
102 |         /// <summary>
103 |         ///   Do nothing on completed.
104 |         /// </summary>
105 |         public void OnCompleted()
106 |         {
107 |         }
108 | 
109 |         /// <summary>
110 |         ///   Re-throw on error.
111 |         /// </summary>
112 |         public void OnError(Exception error)
113 |         {
114 |             throw error;
115 |         }
116 | 
117 |         /// <summary>
118 |         ///   Static helper function.
119 |         /// </summary>
120 |         private static bool Implies(bool A, bool B)
121 |         {
122 |             return ((!A) || B);
123 |         }
124 | 
125 |         /// <summary>
126 |         ///   Static helper function.
127 |         /// </summary>
128 |         private static bool Iff(bool A, bool B)
129 |         {
130 |             return Implies(A, B) && Implies(B, A);
131 |         }
132 | 
133 |         /// <summary>
134 |         ///   LastV contains the mapping from state to probability
135 |         ///   of most-probable-paths-to-the-state that was produced
136 |         ///   by the prior observation.
137 |         /// </summary>
138 |         private Dictionary<S, double> LastV { get; set; }
139 | 
140 |         /// <summary>
141 |         ///   OnNext takes a tuple of an observation and a sequence of
142 |         ///   states that might have emitted this observation (the
143 |         ///   FROM states).  The name of the tuple is "value".  The
144 |         ///   observation is in "value.Item1" and the sequence of
145 |         ///   states is in "value.Item2".
146 |         /// </summary>
147 |         public void OnNext(Tuple<O, IEnumerable<S>> value)
148 |         {
149 |             Contract.Requires(value.Item2 != null);
150 |             // Contract.Requires fails here due to visibility of the properties.
151 |             Contract.Assert(Iff(TargetStates == null, LastV == null));
152 | 
153 |             // True only first time around -- at bootstrapping time.
154 |             if (TargetStates == null)
155 |             {
156 |                 // Initialize the HISTORY LIST of maps from state to
157 |                 // probability-of-most-probable-path.
158 |                 _V = new List<Dictionary<S, double>>();
159 | 
160 |                 // Initialize the map from state to
161 |                 // most-probable-path-leading-to-state.
162 |                 Path = new Dictionary<S, List<S>>();
163 | 
164 |                 // Initialize the FIRST map from state to probability
165 |                 // of most-probable-path leading to the state.
166 |                 var firstV = new Dictionary<S, double>();
167 | 
168 |                 // value.Item2 contains the FROM states: the states
169 |                 // that might have emitted this observation.  Now
170 |                 // compute the probabilities for transition to all the
171 |                 // TO states.  In this bootstrapping case, the
172 |                 // probabilities are simply the emission
173 |                 // probabilities -- the probabilities that the state
174 |                 // produced this observation -- times the probability
175 |                 // that the system was in that state.
176 |                 foreach (var state in value.Item2)
177 |                 {
178 |                     // The probability of the most probable path
179 |                     // leading to "state" given observation is the
180 |                     // a-priori probability of state times the
181 |                     // conditional probability of observation given
182 |                     // the state.  Observation is in the slot
183 |                     // "value.Item1."
184 |                     firstV[state] =
185 |                         StartingProbabilities(state) *
186 |                         EmissionProbabilities(state, value.Item1);
187 | 
188 |                     // The state that yielded the transition to this
189 |                     // most probable path is just "state" itself.
190 |                     Path[state] = new List<S>();
191 |                     Path[state].Add(state);
192 |                 }
193 |                 // The possible targets for the next transition are in
194 |                 // the states, in-turn in slot "value.Item2."
195 |                 TargetStates = value.Item2;
196 |                 _V.Add(firstV);
197 |                 LastV = firstV;
198 |                 return;
199 |             }
200 | 
201 |             // The source states for this observation are the target
202 |             // states from the last observation (Viterbi, strictly
203 |             // speaking, has a memory of ONE transition).  In case of
204 |             // the first observation -- the bootstrapping case, this
205 |             // is also true, it just so happens that the source and
206 |             // target states are the same during bootstrapping.
207 |             SourceStates = TargetStates;
208 | 
209 |             // The target states for this observation are in the input
210 |             // to OnNext.
211 |             TargetStates = value.Item2;
212 | 
213 |             // Space for the new probabilities of the
214 |             // most-probable-paths leading to each state.
215 |             var nextV = new Dictionary<S, double>();
216 | 
217 |             // and for each candidate target state . . .
218 |             foreach (var target in TargetStates)
219 |             {
220 |                 // . . . find the SOURCE state that leads to the most
221 |                 // probable path to the target.
222 |                 //
223 |                 // Maximize over the prior states: the transition
224 |                 // probabilities from the source state, times the
225 |                 // conditional probabilities of seeing the actual
226 |                 // observation given the candidate source state, times
227 |                 // the probability of the most-probable-path leading
228 |                 // to the source state.  Use the LINQ non-standard
229 |                 // query operator "ArgAndMax," which, for any
230 |                 // IEnumerable, finds the input (the arg or "source")
231 |                 // that produces the maximum value of its given
232 |                 // function (lambda expression), and also that maximum
233 |                 // value, returning both the argument and the maximum
234 |                 // in an instance of class ArgumentValuePair.
235 |                 //
236 |                 // In this lambda expression, "target" is fixed
237 |                 // (closed over).
238 |                 var maxStateAndProb = SourceStates.ArgAndMax(source =>
239 |                 {
240 |                     // probability of the most probable path that led
241 |                     // to source
242 |                     var a = LastV[source];
243 | 
244 |                     // transition probability from source to target
245 |                     var b = TransitionProbabilities(source, target);
246 | 
247 |                     // probability of seeing actual observation if we
248 |                     // are in the target state; observation is stored
249 |                     // in value.Item1.
250 |                     var c = EmissionProbabilities(target, value.Item1);
251 | 
252 |                     return a * b * c;
253 |                 });
254 | 
255 |                 // After this point, we have found the SOURCE state
256 |                 // that produces the most probable path to the given
257 |                 // target state and yielding the given observation.
258 |                 // Save the probability of that most-probable-path.
259 |                 nextV[target] = maxStateAndProb.Value;
260 | 
261 |                 // Copy the most probable path that led to the source
262 |                 // state that yields the maximum probability.  I must 
263 |                 // copy it because this path might be the same for 
264 |                 // multiple targets, and each target will need its own
265 |                 // copy of the prior path to append itself to.
266 |                 var newpath = new List<S>(Path[maxStateAndProb.Argument]);
267 | 
268 |                 // Append the current state.
269 |                 newpath.Add(target);
270 | 
271 |                 // Replace the path to the current target with the
272 |                 // refreshed one.
273 |                 Path[target] = newpath;
274 |             }
275 |             _V.Add(nextV);
276 |             LastV = nextV;
277 |         }
278 |     }
279 | }
280 | 


--------------------------------------------------------------------------------
/Viterbi/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following 
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("Experimental.MachineLearning.Viterbi")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("Microsoft")]
12 | [assembly: AssemblyProduct("Experimental.MachineLearning.Viterbi")]
13 | [assembly: AssemblyCopyright("Copyright © Microsoft 2011")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible 
18 | // to COM components.  If you need to access a type in this assembly from 
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("450f652c-1f1f-40bd-9ace-caea681ca90d")]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version 
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers 
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("1.0.0.0")]
36 | [assembly: AssemblyFileVersion("1.0.0.0")]
37 | 


--------------------------------------------------------------------------------
/Viterbi/Viterbi.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <PropertyGroup>
  4 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  5 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  6 |     <ProductVersion>8.0.30703</ProductVersion>
  7 |     <SchemaVersion>2.0</SchemaVersion>
  8 |     <ProjectGuid>{021A5039-3860-49DB-9D6F-B2B8C14497A8}</ProjectGuid>
  9 |     <OutputType>Library</OutputType>
 10 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 11 |     <RootNamespace>Monza.MachineLearning.Viterbi</RootNamespace>
 12 |     <AssemblyName>Viterbi</AssemblyName>
 13 |     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
 14 |     <FileAlignment>512</FileAlignment>
 15 |     <SccProjectName>
 16 |     </SccProjectName>
 17 |     <SccLocalPath>
 18 |     </SccLocalPath>
 19 |     <SccAuxPath>
 20 |     </SccAuxPath>
 21 |     <SccProvider>
 22 |     </SccProvider>
 23 |     <CodeContractsAssemblyMode>0</CodeContractsAssemblyMode>
 24 |   </PropertyGroup>
 25 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 26 |     <DebugSymbols>true</DebugSymbols>
 27 |     <DebugType>full</DebugType>
 28 |     <Optimize>false</Optimize>
 29 |     <OutputPath>bin\Debug\</OutputPath>
 30 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 31 |     <ErrorReport>prompt</ErrorReport>
 32 |     <WarningLevel>4</WarningLevel>
 33 |     <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
 34 |     <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
 35 |     <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
 36 |     <CodeContractsRuntimeCallSiteRequires>True</CodeContractsRuntimeCallSiteRequires>
 37 |     <CodeContractsRunCodeAnalysis>True</CodeContractsRunCodeAnalysis>
 38 |     <CodeContractsNonNullObligations>True</CodeContractsNonNullObligations>
 39 |     <CodeContractsBoundsObligations>True</CodeContractsBoundsObligations>
 40 |     <CodeContractsArithmeticObligations>True</CodeContractsArithmeticObligations>
 41 |     <CodeContractsRedundantAssumptions>True</CodeContractsRedundantAssumptions>
 42 |     <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
 43 |     <CodeContractsShowSquigglies>True</CodeContractsShowSquigglies>
 44 |     <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
 45 |     <CodeContractsEmitXMLDocs>True</CodeContractsEmitXMLDocs>
 46 |     <CodeContractsCustomRewriterAssembly />
 47 |     <CodeContractsCustomRewriterClass />
 48 |     <CodeContractsLibPaths />
 49 |     <CodeContractsExtraRewriteOptions />
 50 |     <CodeContractsExtraAnalysisOptions />
 51 |     <CodeContractsBaseLineFile />
 52 |     <CodeContractsCacheAnalysisResults>True</CodeContractsCacheAnalysisResults>
 53 |     <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
 54 |     <CodeContractsReferenceAssembly>Build</CodeContractsReferenceAssembly>
 55 |     <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
 56 |     <CodeContractsEnumObligations>False</CodeContractsEnumObligations>
 57 |     <CodeContractsAnalysisWarningLevel>0</CodeContractsAnalysisWarningLevel>
 58 |   </PropertyGroup>
 59 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 60 |     <DebugType>pdbonly</DebugType>
 61 |     <Optimize>true</Optimize>
 62 |     <OutputPath>bin\Release\</OutputPath>
 63 |     <DefineConstants>TRACE</DefineConstants>
 64 |     <ErrorReport>prompt</ErrorReport>
 65 |     <WarningLevel>4</WarningLevel>
 66 |   </PropertyGroup>
 67 |   <ItemGroup>
 68 |     <Reference Include="System" />
 69 |     <Reference Include="System.Core" />
 70 |     <Reference Include="System.Xml.Linq" />
 71 |     <Reference Include="System.Data.DataSetExtensions" />
 72 |     <Reference Include="Microsoft.CSharp" />
 73 |     <Reference Include="System.Data" />
 74 |     <Reference Include="System.Xml" />
 75 |   </ItemGroup>
 76 |   <ItemGroup>
 77 |     <Compile Include="FunctionBasedViterbi.cs" />
 78 |     <Compile Include="Properties\AssemblyInfo.cs" />
 79 |   </ItemGroup>
 80 |   <ItemGroup>
 81 |     <ProjectReference Include="..\DotNetExtensions.csproj">
 82 |       <Project>{929C6B38-22D8-42EC-8D24-03678DFAF228}</Project>
 83 |       <Name>DotNetExtensions</Name>
 84 |     </ProjectReference>
 85 |   </ItemGroup>
 86 |   <ItemGroup>
 87 |     <None Include="contractsUserdoc.pdf" />
 88 |   </ItemGroup>
 89 |   <ItemGroup>
 90 |     <Content Include="contractsUserdoc.txt" />
 91 |   </ItemGroup>
 92 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 93 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
 94 |        Other similar extension points exist, see Microsoft.Common.targets.
 95 |   <Target Name="BeforeBuild">
 96 |   </Target>
 97 |   <Target Name="AfterBuild">
 98 |   </Target>
 99 |   -->
100 | </Project>


--------------------------------------------------------------------------------
/Viterbi/contractsUserdoc.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rebcabin/DotNetExtensionsImproved/ff493b09393da1ed1fd01c8a85aea2178179dfee/Viterbi/contractsUserdoc.pdf


--------------------------------------------------------------------------------
/Viterbi/contractsUserdoc.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rebcabin/DotNetExtensionsImproved/ff493b09393da1ed1fd01c8a85aea2178179dfee/Viterbi/contractsUserdoc.txt


--------------------------------------------------------------------------------
/ViterbiTests/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following 
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("ViterbiTests")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("Microsoft")]
12 | [assembly: AssemblyProduct("ViterbiTests")]
13 | [assembly: AssemblyCopyright("Copyright © Microsoft 2011")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible 
18 | // to COM components.  If you need to access a type in this assembly from 
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("ae4ec75e-0414-4879-9395-db7c5c4557a0")]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version 
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers 
33 | // by using the '*' as shown below:
34 | [assembly: AssemblyVersion("1.0.0.0")]
35 | [assembly: AssemblyFileVersion("1.0.0.0")]
36 | 


--------------------------------------------------------------------------------
/ViterbiTests/ViterbiTest1.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using Microsoft.VisualStudio.TestTools.UnitTesting;
 5 | using Experimental.DotNetExtensions;
 6 | using Experimental.MachineLearning.Viterbi;
 7 | 
 8 | namespace ViterbiTests
 9 | {
10 |     [TestClass]
11 |     public class ViterbiTest1
12 |     {
13 |         [TestMethod]
14 |         public void WikipediaUnitTest()
15 |         {
16 |             var Rainy = "Rainy";
17 |             var Sunny = "Sunny";
18 | 
19 |             var Walk = "Walk";
20 |             var Shop = "Shop";
21 |             var Clean = "Clean";
22 | 
23 |             var states = new[] { Rainy, Sunny };
24 |             var observations = new[] { Walk, Shop, Clean };
25 | 
26 |             const double RainyProb = 0.6D;
27 |             const double SunnyProb = 1D - RainyProb;
28 | 
29 |             const double RainyToRainyProb = 0.7D;
30 |             const double RainyToSunnyProb = 1D - RainyToRainyProb;
31 | 
32 |             const double SunnyToRainyProb = 0.4D;
33 |             const double SunnyToSunnyProb = 1D - SunnyToRainyProb;
34 | 
35 |             const double RainyWalkProb = 0.1D;
36 |             const double RainyShopProb = 0.4D;
37 |             const double RainyCleanProb = 1D - RainyWalkProb - RainyShopProb;
38 | 
39 |             const double SunnyWalkProb = 0.6D;
40 |             const double SunnyShopProb = 0.3D;
41 |             const double SunnyCleanProb = 1 - SunnyWalkProb - SunnyShopProb;
42 | 
43 |             var startingProbabilitiesDict = IDictionary
44 |                 .AddUnconditionally(Rainy, RainyProb)
45 |                 .AddUnconditionally(Sunny, SunnyProb);
46 | 
47 |             var transitionProbabilitiesDict = IDictionary
48 |                 .AddUnconditionally(Rainy, IDictionary
49 |                     .AddUnconditionally(Rainy, RainyToRainyProb)
50 |                     .AddUnconditionally(Sunny, RainyToSunnyProb))
51 |                 .AddUnconditionally(Sunny, IDictionary
52 |                     .AddUnconditionally(Rainy, SunnyToRainyProb)
53 |                     .AddUnconditionally(Sunny, SunnyToSunnyProb));
54 | 
55 |             var emissionProbabilitiesDict = IDictionary
56 |                 .AddUnconditionally(Rainy, IDictionary
57 |                     .AddUnconditionally(Walk, RainyWalkProb)
58 |                     .AddUnconditionally(Shop, RainyShopProb)
59 |                     .AddUnconditionally(Clean, RainyCleanProb))
60 |                 .AddUnconditionally(Sunny, IDictionary
61 |                     .AddUnconditionally(Walk, SunnyWalkProb)
62 |                     .AddUnconditionally(Shop, SunnyShopProb)
63 |                     .AddUnconditionally(Clean, SunnyCleanProb));
64 | 
65 |             try
66 |             {
67 |                 var fbv = new FunctionBasedDoubleViterbi<string, string>
68 |                     (startingProbabilities: (s => startingProbabilitiesDict[s])
69 |                     , transitionProbabilities: ((sOut, sIn) => transitionProbabilitiesDict[sOut][sIn])
70 |                     , emissionProbabilities: ((s, o) => emissionProbabilitiesDict[s][o])
71 |                     );
72 | 
73 |                 var obsStates = observations
74 |                     .Zip(
75 |                         new[] { states }.Repeat(),
76 |                         (o, ss) => Tuple.Create(o, (IEnumerable<string>)ss))
77 |                     .ToObservable()
78 |                     ;
79 | 
80 |                 obsStates.Subscribe(fbv);
81 | 
82 |                 var finalProbabilities = fbv.V.Last();
83 | 
84 |                 Assert.AreEqual(Math.Round(finalProbabilities[Rainy], 6), 0.013440d);
85 |                 Assert.AreEqual(Math.Round(finalProbabilities[Sunny], 6), 0.002592d);
86 | 
87 |                 var mostProbableState = states.ArgMax(y => finalProbabilities[y]);
88 | 
89 |                 Assert.AreEqual(mostProbableState, Rainy);
90 |             }
91 |             catch (Exception ex)
92 |             {
93 |                 throw ex;
94 |             }
95 |         }
96 |     }
97 | }
98 | 


--------------------------------------------------------------------------------
/ViterbiTests/ViterbiTests.csproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <PropertyGroup>
 4 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 5 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 6 |     <ProductVersion>
 7 |     </ProductVersion>
 8 |     <SchemaVersion>2.0</SchemaVersion>
 9 |     <ProjectGuid>{CF26536C-4497-4760-914E-4FCA8F57A283}</ProjectGuid>
10 |     <OutputType>Library</OutputType>
11 |     <AppDesignerFolder>Properties</AppDesignerFolder>
12 |     <RootNamespace>ViterbiTests</RootNamespace>
13 |     <AssemblyName>ViterbiTests</AssemblyName>
14 |     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
15 |     <FileAlignment>512</FileAlignment>
16 |     <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
17 |     <SccProjectName>
18 |     </SccProjectName>
19 |     <SccLocalPath>
20 |     </SccLocalPath>
21 |     <SccAuxPath>
22 |     </SccAuxPath>
23 |     <SccProvider>
24 |     </SccProvider>
25 |   </PropertyGroup>
26 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
27 |     <DebugSymbols>true</DebugSymbols>
28 |     <DebugType>full</DebugType>
29 |     <Optimize>false</Optimize>
30 |     <OutputPath>bin\Debug\</OutputPath>
31 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
32 |     <ErrorReport>prompt</ErrorReport>
33 |     <WarningLevel>4</WarningLevel>
34 |   </PropertyGroup>
35 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
36 |     <DebugType>pdbonly</DebugType>
37 |     <Optimize>true</Optimize>
38 |     <OutputPath>bin\Release\</OutputPath>
39 |     <DefineConstants>TRACE</DefineConstants>
40 |     <ErrorReport>prompt</ErrorReport>
41 |     <WarningLevel>4</WarningLevel>
42 |   </PropertyGroup>
43 |   <ItemGroup>
44 |     <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
45 |     <Reference Include="System" />
46 |     <Reference Include="System.Core">
47 |       <RequiredTargetFramework>3.5</RequiredTargetFramework>
48 |     </Reference>
49 |     <Reference Include="System.CoreEx, Version=1.0.2838.104, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
50 |       <HintPath>..\..\..\..\Main\Monza\Published\ReactiveFramework\System.CoreEx.dll</HintPath>
51 |     </Reference>
52 |     <Reference Include="System.Interactive, Version=1.0.2838.104, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
53 |       <HintPath>..\..\..\..\Main\Monza\Published\ReactiveFramework\System.Interactive.dll</HintPath>
54 |     </Reference>
55 |     <Reference Include="System.Reactive, Version=1.0.2838.104, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
56 |       <HintPath>..\..\..\..\Main\Monza\Published\ReactiveFramework\System.Reactive.dll</HintPath>
57 |     </Reference>
58 |   </ItemGroup>
59 |   <ItemGroup>
60 |     <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
61 |       <Visible>False</Visible>
62 |     </CodeAnalysisDependentAssemblyPaths>
63 |   </ItemGroup>
64 |   <ItemGroup>
65 |     <Compile Include="Properties\AssemblyInfo.cs" />
66 |     <Compile Include="ViterbiTest1.cs" />
67 |   </ItemGroup>
68 |   <ItemGroup>
69 |     <ProjectReference Include="..\DotNetExtensions.csproj">
70 |       <Project>{929C6B38-22D8-42EC-8D24-03678DFAF228}</Project>
71 |       <Name>DotNetExtensions</Name>
72 |     </ProjectReference>
73 |     <ProjectReference Include="..\Viterbi\Viterbi.csproj">
74 |       <Project>{021A5039-3860-49DB-9D6F-B2B8C14497A8}</Project>
75 |       <Name>Viterbi</Name>
76 |     </ProjectReference>
77 |   </ItemGroup>
78 |   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
79 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
80 |        Other similar extension points exist, see Microsoft.Common.targets.
81 |   <Target Name="BeforeBuild">
82 |   </Target>
83 |   <Target Name="AfterBuild">
84 |   </Target>
85 |   -->
86 | </Project>


--------------------------------------------------------------------------------
/ViterbiTests/bin/Debug/System.CoreEx.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rebcabin/DotNetExtensionsImproved/ff493b09393da1ed1fd01c8a85aea2178179dfee/ViterbiTests/bin/Debug/System.CoreEx.dll


--------------------------------------------------------------------------------
/ViterbiTests/bin/Debug/System.Interactive.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rebcabin/DotNetExtensionsImproved/ff493b09393da1ed1fd01c8a85aea2178179dfee/ViterbiTests/bin/Debug/System.Interactive.dll


--------------------------------------------------------------------------------
/ViterbiTests/bin/Debug/System.Reactive.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rebcabin/DotNetExtensionsImproved/ff493b09393da1ed1fd01c8a85aea2178179dfee/ViterbiTests/bin/Debug/System.Reactive.dll


--------------------------------------------------------------------------------
/ViterbiTests/bin/Release/System.CoreEx.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rebcabin/DotNetExtensionsImproved/ff493b09393da1ed1fd01c8a85aea2178179dfee/ViterbiTests/bin/Release/System.CoreEx.dll


--------------------------------------------------------------------------------
/ViterbiTests/bin/Release/System.Interactive.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rebcabin/DotNetExtensionsImproved/ff493b09393da1ed1fd01c8a85aea2178179dfee/ViterbiTests/bin/Release/System.Interactive.dll


--------------------------------------------------------------------------------
/ViterbiTests/bin/Release/System.Reactive.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rebcabin/DotNetExtensionsImproved/ff493b09393da1ed1fd01c8a85aea2178179dfee/ViterbiTests/bin/Release/System.Reactive.dll


--------------------------------------------------------------------------------
/iSynapticSubset/IMaybe.cs:
--------------------------------------------------------------------------------
 1 | // The MIT License
 2 | 
 3 | // Portions Copyright (c) 2011 Jordan E. Terrell, licensed to 
 4 | // Microsoft Corporation under the MIT license (copied below).
 5 | // 
 6 | // Portions Copyright (c) 2011 Microsoft Corporation
 7 | 
 8 | // Permission is hereby granted, free of charge, to any person obtaining
 9 | // a copy of this software and associated documentation files (the
10 | // "Software"), to deal in the Software without restriction, including
11 | // without limitation the rights to use, copy, modify, merge, publish,
12 | // distribute, sublicense, and/or sell copies of the Software, and to
13 | // permit persons to whom the Software is furnished to do so, subject to
14 | // the following conditions:
15 | 
16 | // The above copyright notice and this permission notice shall be
17 | // included in all copies or substantial portions of the Software.
18 | 
19 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22 | // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
23 | // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
24 | // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
25 | // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 | 
27 | using System;
28 | 
29 | // Adapted under terms of the MIT attribution-only license from Jordan E. Terrell.
30 | 
31 | namespace Experimental.DotNetExtensions.iSynaptic
32 | {
33 |     public interface IMaybe<out T> : IMaybe
34 |     {
35 |         new T Value { get; }
36 |     }
37 | 
38 |     public interface IMaybe
39 |     {
40 |         object Value { get; }
41 |         bool HasValue { get; }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/iSynapticSubset/Maybe.cs:
--------------------------------------------------------------------------------
   1 | // The MIT License
   2 | 
   3 | // Portions Copyright (c) 2011 Jordan E. Terrell, licensed to 
   4 | // Microsoft Corporation under the MIT license (copied below).
   5 | // 
   6 | // Portions Copyright (c) 2011 Microsoft Corporation
   7 | 
   8 | // Permission is hereby granted, free of charge, to any person obtaining
   9 | // a copy of this software and associated documentation files (the
  10 | // "Software"), to deal in the Software without restriction, including
  11 | // without limitation the rights to use, copy, modify, merge, publish,
  12 | // distribute, sublicense, and/or sell copies of the Software, and to
  13 | // permit persons to whom the Software is furnished to do so, subject to
  14 | // the following conditions:
  15 | 
  16 | // The above copyright notice and this permission notice shall be
  17 | // included in all copies or substantial portions of the Software.
  18 | 
  19 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  22 | // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  23 | // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  24 | // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  25 | // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26 | 
  27 | using System;
  28 | using System.Collections.Generic;
  29 | using System.ComponentModel;
  30 | using System.Diagnostics.Contracts;
  31 | using System.Linq;
  32 | using System.Threading;
  33 | using System.Threading.Tasks;
  34 | 
  35 | namespace Experimental.DotNetExtensions.iSynaptic
  36 | {
  37 |     // Implementation of the Maybe monad. http://en.wikipedia.org/wiki/Monad_%28functional_programming%29#Maybe_monad
  38 |     // Thanks to Brian Beckman for his suggestions and assistance.
  39 |     // Don't Fear the Monad! http://channel9.msdn.com/shows/Going+Deep/Brian-Beckman-Dont-fear-the-Monads/
  40 |     public struct Maybe<T> : IMaybe<T>, IEquatable<Maybe<T>>, IEquatable<T>
  41 |     {
  42 |         public static readonly Maybe<T> NoValue;
  43 | 
  44 |         private readonly T _Value;
  45 |         private readonly bool _HasValue;
  46 | 
  47 |         private readonly Func<Maybe<T>> _Computation;
  48 | 
  49 |         public Maybe(T value)
  50 |             : this()
  51 |         {
  52 |             _Value = value;
  53 |             _HasValue = value != null;
  54 |         }
  55 | 
  56 |         public Maybe(Func<Maybe<T>> computation)
  57 |             : this()
  58 |         {
  59 |             var cachedComputation = computation; //Guard.NotNull(computation, "computation");
  60 |             var memoizedResult = default(Maybe<T>);
  61 |             var resultComputed = false;
  62 | 
  63 |             _Computation = () =>
  64 |             {
  65 |                 if (resultComputed)
  66 |                     return memoizedResult;
  67 | 
  68 |                 memoizedResult = cachedComputation();
  69 |                 resultComputed = true;
  70 |                 cachedComputation = null;
  71 | 
  72 |                 return memoizedResult;
  73 |             };
  74 |         }
  75 | 
  76 |         public T Value
  77 |         {
  78 |             get
  79 |             {
  80 |                 if (_Computation != null)
  81 |                     return _Computation().Value;
  82 | 
  83 |                 if (typeof(T) == typeof(Unit) || _HasValue)
  84 |                     return _Value;
  85 | 
  86 |                 throw new InvalidOperationException("No value can be computed.");
  87 |             }
  88 |         }
  89 | 
  90 |         object IMaybe.Value
  91 |         {
  92 |             get { return Value; }
  93 |         }
  94 | 
  95 |         public bool HasValue
  96 |         {
  97 |             get
  98 |             {
  99 |                 if (_Computation != null)
 100 |                     return _Computation().HasValue;
 101 | 
 102 |                 return typeof(T) == typeof(Unit) ||
 103 |                        _HasValue;
 104 |             }
 105 |         }
 106 | 
 107 |         public bool Equals(T other)
 108 |         {
 109 |             return Equals(other, EqualityComparer<T>.Default);
 110 |         }
 111 | 
 112 |         public bool Equals(T other, IEqualityComparer<T> comparer)
 113 |         {
 114 |             return Equals(new Maybe<T>(other), comparer);
 115 |         }
 116 | 
 117 |         public bool Equals(Maybe<T> other)
 118 |         {
 119 |             return Equals(other, EqualityComparer<T>.Default);
 120 |         }
 121 | 
 122 |         public bool Equals(Maybe<T> other, IEqualityComparer<T> comparer)
 123 |         {
 124 |             //Guard.NotNull(comparer, "comparer");
 125 | 
 126 |             if (!HasValue)
 127 |                 return !other.HasValue;
 128 | 
 129 |             return other.HasValue && comparer.Equals(Value, other.Value);
 130 |         }
 131 | 
 132 |         public override bool Equals(object obj)
 133 |         {
 134 |             if (obj is Maybe<T>)
 135 |                 return Equals((Maybe<T>)obj);
 136 | 
 137 |             if (obj is T)
 138 |                 return Equals(new Maybe<T>((T)obj));
 139 | 
 140 |             return false;
 141 |         }
 142 | 
 143 |         public override int GetHashCode()
 144 |         {
 145 |             return GetHashCode(EqualityComparer<T>.Default);
 146 |         }
 147 | 
 148 |         public int GetHashCode(IEqualityComparer<T> comparer)
 149 |         {
 150 |             // Guard.NotNull(comparer, "comparer");
 151 | 
 152 |             return HasValue
 153 |                 ? comparer.GetHashCode(Value)
 154 |                 : 0;
 155 |         }
 156 | 
 157 |         public static bool operator ==(Maybe<T> left, Maybe<T> right)
 158 |         {
 159 |             return left.Equals(right);
 160 |         }
 161 | 
 162 |         public static bool operator !=(Maybe<T> left, Maybe<T> right)
 163 |         {
 164 |             return !(left == right);
 165 |         }
 166 | 
 167 |         public static bool operator ==(Maybe<T> left, T right)
 168 |         {
 169 |             return left.Equals(right);
 170 |         }
 171 | 
 172 |         public static bool operator !=(Maybe<T> left, T right)
 173 |         {
 174 |             return !(left == right);
 175 |         }
 176 | 
 177 |         public static bool operator ==(T left, Maybe<T> right)
 178 |         {
 179 |             return right.Equals(left);
 180 |         }
 181 | 
 182 |         public static bool operator !=(T left, Maybe<T> right)
 183 |         {
 184 |             return !(left == right);
 185 |         }
 186 | 
 187 |         public static explicit operator T(Maybe<T> value)
 188 |         {
 189 |             return value.Value;
 190 |         }
 191 | 
 192 |         public static implicit operator Maybe<T>(Maybe<Unit> value)
 193 |         {
 194 |             return new Maybe<T>();
 195 |         }
 196 |     }
 197 | 
 198 |     public static class Maybe
 199 |     {
 200 |         #region Defer Operator
 201 | 
 202 |         public static Maybe<T> Defer<T>(Func<T> computation)
 203 |         {
 204 |             //Guard.NotNull(computation, "computation");
 205 | 
 206 |             return new Maybe<T>(() => new Maybe<T>(computation()));
 207 |         }
 208 | 
 209 |         public static Maybe<T> Defer<T>(Func<T?> computation) where T : struct
 210 |         {
 211 |             //Guard.NotNull(computation, "computation");
 212 | 
 213 |             return new Maybe<T>(() => Return(computation()));
 214 |         }
 215 | 
 216 |         public static Maybe<T> Defer<T>(Func<Maybe<T>> computation)
 217 |         {
 218 |             return new Maybe<T>(computation);
 219 |         }
 220 | 
 221 |         #endregion
 222 | 
 223 |         #region If Operator
 224 | 
 225 |         public static Maybe<T> If<T>(bool predicate, Maybe<T> thenValue)
 226 |         {
 227 |             return predicate ? thenValue : NoValue;
 228 |         }
 229 | 
 230 |         public static Maybe<T> If<T>(bool predicate, Maybe<T> thenValue, Maybe<T> elseValue)
 231 |         {
 232 |             return predicate ? thenValue : elseValue;
 233 |         }
 234 | 
 235 |         public static Maybe<T> If<T>(Func<bool> predicate, Maybe<T> thenValue)
 236 |         {
 237 |             //Guard.NotNull(predicate, "predicate");
 238 |             return new Maybe<T>(() => predicate() ? thenValue : NoValue);
 239 |         }
 240 | 
 241 |         public static Maybe<T> If<T>(Func<bool> predicate, Maybe<T> thenValue, Maybe<T> elseValue)
 242 |         {
 243 |             //Guard.NotNull(predicate, "predicate");
 244 |             return new Maybe<T>(() => predicate() ? thenValue : elseValue);
 245 |         }
 246 | 
 247 |         #endregion
 248 | 
 249 |         #region Using Operator
 250 | 
 251 |         public static Maybe<T> Using<T, TResource>(Func<TResource> resourceFactory, Func<TResource, Maybe<T>> selector) where TResource : IDisposable
 252 |         {
 253 |             //Guard.NotNull(resourceFactory, "resourceFactory");
 254 |             //Guard.NotNull(selector, "selector");
 255 | 
 256 |             return new Maybe<T>(() =>
 257 |             {
 258 |                 using (var resource = resourceFactory())
 259 |                     return selector(resource);
 260 |             });
 261 |         }
 262 | 
 263 |         public static Maybe<TResult> Using<T, TResource, TResult>(this Maybe<T> @this, Func<T, TResource> resourceSelector, Func<TResource, Maybe<TResult>> selector) where TResource : IDisposable
 264 |         {
 265 |             //Guard.NotNull(resourceSelector, "resourceSelector");
 266 |             //Guard.NotNull(selector, "selector");
 267 | 
 268 |             return @this.SelectMaybe(x =>
 269 |             {
 270 |                 using (var resource = resourceSelector(x))
 271 |                     return selector(resource);
 272 |             });
 273 |         }
 274 | 
 275 |         #endregion
 276 | 
 277 |         #region ValueOrDefault Operator
 278 | 
 279 |         public static T ValueOrDefault<T>(this Maybe<T> @this, Func<T> @default)
 280 |         {
 281 |             return @this.HasValue
 282 |                 ? @this.Value
 283 |                 : @default();
 284 |         }
 285 | 
 286 |         public static T ValueOrDefault<T>(this Maybe<T> @this, T @default)
 287 |         {
 288 |             return @this.HasValue
 289 |                 ? @this.Value
 290 |                 : @default;
 291 |         }
 292 | 
 293 |         public static T ValueOrDefault<T>(this Maybe<T> @this)
 294 |         {
 295 |             return @this.ValueOrDefault(default(T));
 296 |         }
 297 | 
 298 |         #endregion
 299 | 
 300 |         #region Or Operator
 301 | 
 302 |         public static Maybe<T> Or<T>(this Maybe<T> @this, T value)
 303 |         {
 304 |             var self = @this;
 305 |             return new Maybe<T>(() => self.HasValue ? self : new Maybe<T>(value));
 306 |         }
 307 | 
 308 |         public static Maybe<T> Or<T>(this Maybe<T> @this, Func<T> valueFactory)
 309 |         {
 310 |             //Guard.NotNull(valueFactory, "valueFactory");
 311 | 
 312 |             var self = @this;
 313 |             return new Maybe<T>(() => self.HasValue ? self : new Maybe<T>(valueFactory()));
 314 |         }
 315 | 
 316 |         public static Maybe<T> Or<T>(this Maybe<T> @this, Func<Maybe<T>> valueFactory)
 317 |         {
 318 |             //Guard.NotNull(valueFactory, "valueFactory");
 319 | 
 320 |             var self = @this;
 321 |             return new Maybe<T>(() => self.HasValue ? self : valueFactory());
 322 |         }
 323 | 
 324 |         public static Maybe<T> Or<T>(this Maybe<T> @this, Maybe<T> other)
 325 |         {
 326 |             var self = @this;
 327 |             return new Maybe<T>(() => self.HasValue ? self : other);
 328 |         }
 329 | 
 330 |         #endregion
 331 | 
 332 |         #region With Operator
 333 | 
 334 |         public static Maybe<T> With<T, TSelected>(this Maybe<T> @this, Func<T, TSelected> selector, Action<TSelected> action)
 335 |         {
 336 |             //Guard.NotNull(selector, "selector");
 337 |             //Guard.NotNull(action, "action");
 338 | 
 339 |             var self = @this;
 340 | 
 341 |             return new Maybe<T>(() =>
 342 |             {
 343 |                 if (self.HasValue)
 344 |                     action(selector(self.Value));
 345 | 
 346 |                 return self;
 347 |             });
 348 |         }
 349 | 
 350 |         public static Maybe<T> With<T, TSelected>(this Maybe<T> @this, Func<T, Maybe<TSelected>> selector, Action<TSelected> action)
 351 |         {
 352 |             //Guard.NotNull(selector, "selector");
 353 |             //Guard.NotNull(action, "action");
 354 | 
 355 |             var self = @this;
 356 | 
 357 |             return new Maybe<T>(() =>
 358 |             {
 359 |                 if (self.HasValue)
 360 |                 {
 361 |                     var selected = selector(self.Value);
 362 |                     if (selected.HasValue)
 363 |                         action(selected.Value);
 364 |                 }
 365 | 
 366 |                 return self;
 367 |             });
 368 |         }
 369 | 
 370 |         #endregion
 371 | 
 372 |         #region When Operator
 373 | 
 374 |         public static Maybe<T> When<T>(this Maybe<T> @this, T value, Action<T> action)
 375 |         {
 376 |             //Guard.NotNull(action, "action");
 377 | 
 378 |             var self = @this;
 379 |             return new Maybe<T>(() =>
 380 |             {
 381 |                 if (self.HasValue && EqualityComparer<T>.Default.Equals(self.Value, value))
 382 |                     action(self.Value);
 383 | 
 384 |                 return self;
 385 |             });
 386 |         }
 387 | 
 388 |         public static Maybe<T> When<T>(this Maybe<T> @this, T value, Maybe<T> newValue)
 389 |         {
 390 |             var self = @this;
 391 |             return new Maybe<T>(() =>
 392 |             {
 393 |                 if (self.HasValue && EqualityComparer<T>.Default.Equals(self.Value, value))
 394 |                     return newValue;
 395 | 
 396 |                 return self;
 397 |             });
 398 |         }
 399 | 
 400 |         public static Maybe<T> When<T>(this Maybe<T> @this, Func<T, bool> predicate, Action<T> action)
 401 |         {
 402 |             //Guard.NotNull(predicate, "predicate");
 403 |             //Guard.NotNull(action, "action");
 404 | 
 405 |             var self = @this;
 406 |             return new Maybe<T>(() =>
 407 |             {
 408 |                 if (self.HasValue && predicate(self.Value))
 409 |                     action(self.Value);
 410 | 
 411 |                 return self;
 412 |             });
 413 |         }
 414 | 
 415 |         public static Maybe<T> When<T>(this Maybe<T> @this, Func<T, bool> predicate, Maybe<T> newValue)
 416 |         {
 417 |             //Guard.NotNull(predicate, "predicate");
 418 | 
 419 |             var self = @this;
 420 |             return new Maybe<T>(() =>
 421 |             {
 422 |                 if (self.HasValue && predicate(self.Value))
 423 |                     return newValue;
 424 | 
 425 |                 return self;
 426 |             });
 427 |         }
 428 | 
 429 |         public static Maybe<T> When<T>(this Maybe<T> @this, Func<T, bool> predicate, Func<T, Maybe<T>> selector)
 430 |         {
 431 |             //Guard.NotNull(predicate, "predicate");
 432 |             //Guard.NotNull(selector, "selector");
 433 | 
 434 |             var self = @this;
 435 |             return new Maybe<T>(() =>
 436 |             {
 437 |                 if (self.HasValue && predicate(self.Value))
 438 |                     return selector(self.Value);
 439 | 
 440 |                 return self;
 441 |             });
 442 |         }
 443 | 
 444 |         #endregion
 445 | 
 446 |         #region Suppress Operator
 447 | 
 448 |         public static Maybe<T> Suppress<T>(this Maybe<T> @this, Action<Exception> action = null)
 449 |         {
 450 |             var self = @this;
 451 |             return new Maybe<T>(() =>
 452 |             {
 453 |                 try
 454 |                 {
 455 |                     return self.HasValue
 456 |                         ? self
 457 |                         : self;
 458 |                 }
 459 |                 catch (Exception ex)
 460 |                 {
 461 |                     if (action != null)
 462 |                         action(ex);
 463 | 
 464 |                     return NoValue;
 465 |                 }
 466 |             });
 467 |         }
 468 | 
 469 |         public static Maybe<T> Suppress<T>(this Maybe<T> @this, Func<Exception, bool> predicate)
 470 |         {
 471 |             //Guard.NotNull(predicate, "predicate");
 472 | 
 473 |             var self = @this;
 474 |             return new Maybe<T>(() =>
 475 |             {
 476 |                 try
 477 |                 {
 478 |                     return self.HasValue
 479 |                         ? self
 480 |                         : self;
 481 |                 }
 482 |                 catch (Exception ex)
 483 |                 {
 484 |                     if (predicate(ex))
 485 |                         return NoValue;
 486 | 
 487 |                     throw;
 488 |                 }
 489 |             });
 490 |         }
 491 | 
 492 |         public static Maybe<T> Suppress<T>(this Maybe<T> @this, T value)
 493 |         {
 494 |             var self = @this;
 495 |             return new Maybe<T>(() =>
 496 |             {
 497 |                 try
 498 |                 {
 499 |                     return self.HasValue
 500 |                         ? self
 501 |                         : self;
 502 |                 }
 503 |                 catch
 504 |                 {
 505 |                     return new Maybe<T>(value);
 506 |                 }
 507 |             });
 508 |         }
 509 | 
 510 |         public static Maybe<T> Suppress<T>(this Maybe<T> @this, Func<Exception, bool> predicate, T value)
 511 |         {
 512 |             //Guard.NotNull(predicate, "predicate");
 513 | 
 514 |             var self = @this;
 515 |             return new Maybe<T>(() =>
 516 |             {
 517 |                 try
 518 |                 {
 519 |                     return self.HasValue
 520 |                         ? self
 521 |                         : self;
 522 |                 }
 523 |                 catch (Exception ex)
 524 |                 {
 525 |                     if (predicate(ex))
 526 |                         return new Maybe<T>(value);
 527 | 
 528 |                     throw;
 529 |                 }
 530 |             });
 531 |         }
 532 | 
 533 |         public static Maybe<T> Suppress<T>(this Maybe<T> @this, Func<Exception, bool> predicate, Func<Exception, Maybe<T>> selector)
 534 |         {
 535 |             //Guard.NotNull(predicate, "predicate");
 536 |             //Guard.NotNull(selector, "selector");
 537 | 
 538 |             var self = @this;
 539 |             return new Maybe<T>(() =>
 540 |             {
 541 |                 try
 542 |                 {
 543 |                     return self.HasValue
 544 |                         ? self
 545 |                         : self;
 546 |                 }
 547 |                 catch (Exception ex)
 548 |                 {
 549 |                     if (predicate(ex))
 550 |                         return selector(ex);
 551 | 
 552 |                     throw;
 553 |                 }
 554 |             });
 555 |         }
 556 | 
 557 | 
 558 |         #endregion
 559 | 
 560 |         #region Join Operator
 561 | 
 562 |         public static Maybe<Tuple<T, U>> Join<T, U>(this Maybe<T> @this, Maybe<U> other)
 563 |         {
 564 |             var self = @this;
 565 |             return new Maybe<Tuple<T, U>>(() => self.HasValue && other.HasValue
 566 |                 ? new Maybe<Tuple<T, U>>(Tuple.Create(self.Value, other.Value))
 567 |                 : NoValue);
 568 |         }
 569 | 
 570 |         public static Maybe<TResult> Join<T, U, TResult>(this Maybe<T> @this, Maybe<U> other, Func<T, U, TResult> selector)
 571 |         {
 572 |             //Guard.NotNull(selector, "selector");
 573 | 
 574 |             var self = @this;
 575 |             return new Maybe<TResult>(() => self.HasValue && other.HasValue
 576 |                 ? new Maybe<TResult>(selector(self.Value, other.Value))
 577 |                 : NoValue);
 578 |         }
 579 | 
 580 |         public static Maybe<TResult> Join<T, U, TResult>(this Maybe<T> @this, Maybe<U> other, Func<T, U, TResult?> selector) where TResult : struct
 581 |         {
 582 |             //Guard.NotNull(selector, "selector");
 583 | 
 584 |             var self = @this;
 585 |             return new Maybe<TResult>(() => self.HasValue && other.HasValue
 586 |                 ? Return(selector(self.Value, other.Value))
 587 |                 : NoValue);
 588 |         }
 589 | 
 590 |         public static Maybe<TResult> Join<T, U, TResult>(this Maybe<T> @this, Maybe<U> other, Func<T, U, Maybe<TResult>> selector)
 591 |         {
 592 |             //Guard.NotNull(selector, "selector");
 593 | 
 594 |             var self = @this;
 595 |             return new Maybe<TResult>(() => self.HasValue && other.HasValue
 596 |                 ? selector(self.Value, other.Value)
 597 |                 : NoValue);
 598 |         }
 599 | 
 600 |         #endregion
 601 | 
 602 |         #region ThrowOnNoValue Operator
 603 | 
 604 |         public static Maybe<T> ThrowOnNoValue<T>(this Maybe<T> @this, Exception exception)
 605 |         {
 606 |             //Guard.NotNull(exception, "exception");
 607 | 
 608 |             var self = @this;
 609 |             return new Maybe<T>(() =>
 610 |             {
 611 |                 if (self.HasValue != true)
 612 |                     throw exception;
 613 | 
 614 |                 return self;
 615 |             });
 616 |         }
 617 | 
 618 |         public static Maybe<T> ThrowOnNoValue<T>(this Maybe<T> @this, Func<Exception> exceptionFactory)
 619 |         {
 620 |             //Guard.NotNull(exceptionFactory, "exceptionFactory");
 621 | 
 622 |             var self = @this;
 623 |             return new Maybe<T>(() =>
 624 |             {
 625 |                 if (self.HasValue != true)
 626 |                     throw exceptionFactory();
 627 | 
 628 |                 return self;
 629 |             });
 630 |         }
 631 | 
 632 |         #endregion
 633 | 
 634 |         #region ThrowOn Operator
 635 | 
 636 |         public static Maybe<T> ThrowOn<T>(this Maybe<T> @this, T value, Exception exception)
 637 |         {
 638 |             //Guard.NotNull(exception, "exception");
 639 | 
 640 |             var self = @this;
 641 |             return new Maybe<T>(() =>
 642 |             {
 643 |                 if (self.HasValue && EqualityComparer<T>.Default.Equals(self.Value, value))
 644 |                     throw exception;
 645 | 
 646 |                 return self;
 647 |             });
 648 |         }
 649 | 
 650 |         public static Maybe<T> ThrowOn<T>(this Maybe<T> @this, Func<Maybe<T>, Exception> exceptionSelector)
 651 |         {
 652 |             //Guard.NotNull(exceptionSelector, "exceptionSelector");
 653 | 
 654 |             var self = @this;
 655 |             return new Maybe<T>(() =>
 656 |             {
 657 |                 var ex = exceptionSelector(self);
 658 |                 if (ex != null)
 659 |                     throw ex;
 660 | 
 661 |                 return self;
 662 |             });
 663 |         }
 664 | 
 665 |         #endregion
 666 | 
 667 |         #region ToEnumerable Operator
 668 | 
 669 |         public static IEnumerable<T> ToEnumerable<T>(this Maybe<T> @this)
 670 |         {
 671 |             if (@this.HasValue)
 672 |                 yield return @this.Value;
 673 |         }
 674 | 
 675 |         public static IEnumerable<T> ToEnumerable<T>(params Maybe<T>[] values)
 676 |         {
 677 |             //Guard.NotNull(values, "values");
 678 |             return values
 679 |                 .Where(x => x.HasValue)
 680 |                 .Select(x => x.Value);
 681 |         }
 682 | 
 683 |         public static IEnumerable<T> ToEnumerable<T>(this Maybe<T> @this, IEnumerable<Maybe<T>> others)
 684 |         {
 685 |             //Guard.NotNull(others, "others");
 686 | 
 687 |             return new[] { @this }.Concat(others)
 688 |                 .Where(x => x.HasValue)
 689 |                 .Select(x => x.Value);
 690 |         }
 691 | 
 692 |         #endregion
 693 | 
 694 |         #region Squash Operator
 695 | 
 696 |         public static Maybe<T> Squash<T>(this IMaybe<IMaybe<T>> @this)
 697 |         {
 698 |             var self = @this;
 699 |             return new Maybe<T>(() =>
 700 |             {
 701 |                 if (self == null)
 702 |                     return NoValue;
 703 | 
 704 |                 return self.HasValue
 705 |                     ? self.Value.Cast<T>()
 706 |                     : NoValue;
 707 |             });
 708 |         }
 709 | 
 710 |         public static IEnumerable<T> Squash<T>(this IMaybe<IEnumerable<T>> @this)
 711 |         {
 712 |             if (@this == null || @this.HasValue != true || @this.Value == null)
 713 |                 yield break;
 714 | 
 715 |             foreach (var item in @this.Value)
 716 |                 yield return item;
 717 |         }
 718 | 
 719 |         public static Maybe<T> Squash<T>(this Maybe<Maybe<T>> @this)
 720 |         {
 721 |             var self = @this;
 722 | 
 723 |             return new Maybe<T>(() => self.HasValue
 724 |                 ? self.Value
 725 |                 : NoValue);
 726 |         }
 727 | 
 728 |         public static IEnumerable<T> Squash<T>(this Maybe<IEnumerable<T>> @this)
 729 |         {
 730 |             foreach (var item in @this.ValueOrDefault(Enumerable.Empty<T>()))
 731 |                 yield return item;
 732 |         }
 733 | 
 734 |         #endregion
 735 | 
 736 |         public static Maybe<Unit> NoValue
 737 |         {
 738 |             get { return new Maybe<Unit>(); }
 739 |         }
 740 | 
 741 |         public static Maybe<T> Return<T>(T value)
 742 |         {
 743 |             return new Maybe<T>(value);
 744 |         }
 745 | 
 746 |         public static Maybe<T> Return<T>(T? value) where T : struct
 747 |         {
 748 |             return value.HasValue
 749 |                 ? new Maybe<T>(value.Value)
 750 |                 : NoValue;
 751 |         }
 752 | 
 753 |         public static Maybe<TResult> Bind<T, TResult>(this Maybe<T> @this, Func<T, Maybe<TResult>> selector)
 754 |         {
 755 |             return SelectMaybe(@this, selector);
 756 |         }
 757 | 
 758 |         public static Maybe<TResult> Let<T, TResult>(this Maybe<T> @this, Func<Maybe<T>, Maybe<TResult>> func)
 759 |         {
 760 |             //Guard.NotNull(func, "func");
 761 | 
 762 |             var self = @this;
 763 |             return new Maybe<TResult>(() => func(self));
 764 |         }
 765 | 
 766 |         public static Maybe<TResult> Select<T, TResult>(this Maybe<T> @this, Func<T, TResult> selector)
 767 |         {
 768 |             //Guard.NotNull(selector, "selector");
 769 | 
 770 |             var self = @this;
 771 | 
 772 |             return new Maybe<TResult>(() => self.HasValue ? new Maybe<TResult>(selector(self.Value)) : NoValue);
 773 |         }
 774 | 
 775 |         public static Maybe<TResult> Select<T, TResult>(this Maybe<T> @this, Func<T, TResult?> selector) where TResult : struct
 776 |         {
 777 |             //Guard.NotNull(selector, "selector");
 778 | 
 779 |             var self = @this;
 780 | 
 781 |             return new Maybe<TResult>(() => self.HasValue ? Return(selector(self.Value)) : NoValue);
 782 |         }
 783 | 
 784 |         public static Maybe<TResult> TrySelect<TResult>(TrySelector<TResult> selector)
 785 |         {
 786 |             //Guard.NotNull(selector, "selector");
 787 | 
 788 |             return new Maybe<TResult>(() =>
 789 |             {
 790 |                 TResult result = default(TResult);
 791 | 
 792 |                 return selector(out result)
 793 |                     ? new Maybe<TResult>(result)
 794 |                     : NoValue;
 795 |             });
 796 |         }
 797 | 
 798 |         public static Maybe<TResult> TrySelect<T, TResult>(this Maybe<T> @this, TrySelector<T, TResult> selector)
 799 |         {
 800 |             //Guard.NotNull(selector, "selector");
 801 | 
 802 |             var self = @this;
 803 | 
 804 |             return new Maybe<TResult>(() =>
 805 |             {
 806 |                 if (!self.HasValue)
 807 |                     return NoValue;
 808 | 
 809 |                 TResult result = default(TResult);
 810 | 
 811 |                 return selector(self.Value, out result)
 812 |                     ? new Maybe<TResult>(result)
 813 |                     : NoValue;
 814 |             });
 815 |         }
 816 | 
 817 |         // This functionally is the same as Bind and SelectMany.  Since SelectMany doesn't make sense (because there is at most one value),
 818 |         // the name SelectMaybe communicates better than Bind or SelectMany the semantics of the function.
 819 |         public static Maybe<TResult> SelectMaybe<T, TResult>(this Maybe<T> @this, Func<T, Maybe<TResult>> selector)
 820 |         {
 821 |             //Guard.NotNull(selector, "selector");
 822 | 
 823 |             var self = @this;
 824 | 
 825 |             return new Maybe<TResult>(() => self.HasValue ? selector(self.Value) : NoValue);
 826 |         }
 827 | 
 828 |         public static Maybe<Unit> Throw(Exception exception)
 829 |         {
 830 |             //Guard.NotNull(exception, "exception");
 831 |             return new Maybe<Unit>(() => { throw exception; });
 832 |         }
 833 | 
 834 |         public static Maybe<T> Throw<T>(Exception exception)
 835 |         {
 836 |             //Guard.NotNull(exception, "exception");
 837 |             return new Maybe<T>(() => { throw exception; });
 838 |         }
 839 | 
 840 |         public static Maybe<T> Finally<T>(this Maybe<T> @this, Action finallyAction)
 841 |         {
 842 |             //Guard.NotNull(finallyAction, "finallyAction");
 843 | 
 844 |             var self = @this;
 845 |             return new Maybe<T>(() =>
 846 |             {
 847 |                 try
 848 |                 {
 849 |                     return self.HasValue ? self : self;
 850 |                 }
 851 |                 finally
 852 |                 {
 853 |                     finallyAction();
 854 |                 }
 855 |             });
 856 |         }
 857 | 
 858 |         public static Maybe<T> OnValue<T>(this Maybe<T> @this, Action<T> action)
 859 |         {
 860 |             //Guard.NotNull(action, "action");
 861 | 
 862 |             var self = @this;
 863 |             return new Maybe<T>(() =>
 864 |             {
 865 |                 if (self.HasValue)
 866 |                     action(self.Value);
 867 | 
 868 |                 return self;
 869 |             });
 870 |         }
 871 | 
 872 |         public static Maybe<T> OnNoValue<T>(this Maybe<T> @this, Action action)
 873 |         {
 874 |             //Guard.NotNull(action, "action");
 875 | 
 876 |             var self = @this;
 877 |             return new Maybe<T>(() =>
 878 |             {
 879 |                 if (self.HasValue != true)
 880 |                     action();
 881 | 
 882 |                 return self;
 883 |             });
 884 |         }
 885 | 
 886 |         public static Maybe<T> OnException<T>(this Maybe<T> @this, Action<Exception> handler)
 887 |         {
 888 |             //Guard.NotNull(handler, "handler");
 889 |             var self = @this;
 890 | 
 891 |             return new Maybe<T>(() =>
 892 |             {
 893 |                 try
 894 |                 {
 895 |                     return self.HasValue
 896 |                         ? self
 897 |                         : self;
 898 |                 }
 899 |                 catch (Exception ex)
 900 |                 {
 901 |                     handler(ex);
 902 |                     throw;
 903 |                 }
 904 |             });
 905 |         }
 906 | 
 907 |         public static Maybe<T> Where<T>(this Maybe<T> @this, Func<T, bool> predicate)
 908 |         {
 909 |             //Guard.NotNull(predicate, "predicate");
 910 |             var self = @this;
 911 | 
 912 |             return new Maybe<T>(() =>
 913 |             {
 914 |                 if (self.HasValue)
 915 |                 {
 916 |                     var value = self.Value;
 917 | 
 918 |                     if (predicate(value))
 919 |                         return self;
 920 |                 }
 921 | 
 922 |                 return NoValue;
 923 |             });
 924 |         }
 925 | 
 926 |         public static Maybe<T> Unless<T>(this Maybe<T> @this, Func<T, bool> predicate)
 927 |         {
 928 |             //Guard.NotNull(predicate, "predicate");
 929 |             var self = @this;
 930 | 
 931 |             return new Maybe<T>(() =>
 932 |             {
 933 |                 if (self.HasValue)
 934 |                 {
 935 |                     var value = self.Value;
 936 | 
 937 |                     if (!predicate(value))
 938 |                         return self;
 939 |                 }
 940 | 
 941 |                 return NoValue;
 942 |             });
 943 |         }
 944 | 
 945 |         public static Maybe<T> Assign<T>(this Maybe<T> @this, ref T target)
 946 |         {
 947 |             if (@this.HasValue)
 948 |                 target = @this.Value;
 949 | 
 950 |             return @this;
 951 |         }
 952 | 
 953 |         public static Maybe<T> Run<T>(this Maybe<T> @this, Action<T> action = null)
 954 |         {
 955 |             // Getting HasValue forces evaluation
 956 |             if (@this.HasValue && action != null)
 957 |                 action(@this.Value);
 958 | 
 959 |             return @this;
 960 |         }
 961 | 
 962 |         public static Maybe<T> RunAsync<T>(this Maybe<T> @this, Action<T> action = null, CancellationToken cancellationToken = default(CancellationToken), TaskCreationOptions taskCreationOptions = TaskCreationOptions.None, TaskScheduler taskScheduler = default(TaskScheduler))
 963 |         {
 964 |             var self = @this;
 965 |             var task = Task.Factory.StartNew(() => self.Run(action), cancellationToken, taskCreationOptions, taskScheduler ?? TaskScheduler.Current);
 966 | 
 967 |             return new Maybe<T>(() =>
 968 |             {
 969 |                 task.Wait(cancellationToken);
 970 |                 return task.IsCanceled ? NoValue : self;
 971 |             });
 972 |         }
 973 | 
 974 |         public static Maybe<T> Synchronize<T>(this Maybe<T> @this)
 975 |         {
 976 |             return Synchronize(@this, new object());
 977 |         }
 978 | 
 979 |         public static Maybe<T> Synchronize<T>(this Maybe<T> @this, object gate)
 980 |         {
 981 |             //Guard.NotNull(gate, "gate");
 982 | 
 983 |             var self = @this;
 984 |             return new Maybe<T>(() =>
 985 |             {
 986 |                 lock (gate)
 987 |                 {
 988 |                     return self.Run();
 989 |                 }
 990 |             });
 991 |         }
 992 | 
 993 |         public static Maybe<TResult> Cast<TResult>(this IMaybe @this)
 994 |         {
 995 |             if (@this == null)
 996 |                 return NoValue;
 997 | 
 998 |             if (@this is Maybe<TResult>)
 999 |                 return (Maybe<TResult>)@this;
1000 | 
1001 |             return new Maybe<TResult>(() => @this.HasValue
1002 |                 ? new Maybe<TResult>((TResult)@this.Value)
1003 |                 : NoValue);
1004 |         }
1005 | 
1006 |         public static Maybe<TResult> OfType<TResult>(this IMaybe @this)
1007 |         {
1008 |             if (@this == null)
1009 |                 return NoValue;
1010 | 
1011 |             if (@this is Maybe<TResult>)
1012 |                 return (Maybe<TResult>)@this;
1013 | 
1014 |             return new Maybe<TResult>(() =>
1015 |             {
1016 |                 if (@this.HasValue != true)
1017 |                     return NoValue;
1018 | 
1019 |                 return @this.Value is TResult
1020 |                     ? new Maybe<TResult>((TResult)@this.Value)
1021 |                     : NoValue;
1022 |             });
1023 |         }
1024 | 
1025 |         public static T? ToNullable<T>(this Maybe<T> @this) where T : struct
1026 |         {
1027 |             return @this.HasValue ? (T?)@this.Value : null;
1028 |         }
1029 | 
1030 |         public static T? ToNullable<T>(this Maybe<T?> @this) where T : struct
1031 |         {
1032 |             return @this.HasValue ? @this.Value : null;
1033 |         }
1034 | 
1035 |         // Conventionally, in LINQ, the monadic "return" operator is written "To...,"
1036 |         // as in "ToList," "ToArray," etc. These are synonyms for Return.
1037 |         public static Maybe<T> ToMaybe<T>(this T @this)
1038 |         {
1039 |             return new Maybe<T>(@this);
1040 |         }
1041 | 
1042 |         public static Maybe<T> ToMaybe<T>(this T? @this) where T : struct
1043 |         {
1044 |             return @this.HasValue
1045 |                 ? new Maybe<T>(@this.Value)
1046 |                 : NoValue;
1047 |         }
1048 | 
1049 |         public static Maybe<T> ToMaybe<T>(this object @this)
1050 |         {
1051 |             if (@this is T)
1052 |                 return new Maybe<T>((T)@this);
1053 | 
1054 |             if (@this == null && typeof(T).IsValueType != true)
1055 |                 return new Maybe<T>(default(T));
1056 | 
1057 |             return NoValue;
1058 |         }
1059 | 
1060 |         public static Maybe<T> AsMaybe<T>(this IMaybe<T> value)
1061 |         {
1062 |             return value.OfType<T>();
1063 |         }
1064 | 
1065 |         public static Maybe<object> AsMaybe(this IMaybe value)
1066 |         {
1067 |             return value.OfType<object>();
1068 |         }
1069 |     }
1070 | }
1071 | 


--------------------------------------------------------------------------------
/iSynapticSubset/State.cs:
--------------------------------------------------------------------------------
  1 | // The MIT License
  2 | 
  3 | // Portions Copyright (c) 2011 Jordan E. Terrell, licensed to 
  4 | // Microsoft Corporation under the MIT license (copied below).
  5 | // 
  6 | // Portions Copyright (c) 2011 Microsoft Corporation
  7 | 
  8 | // Permission is hereby granted, free of charge, to any person obtaining
  9 | // a copy of this software and associated documentation files (the
 10 | // "Software"), to deal in the Software without restriction, including
 11 | // without limitation the rights to use, copy, modify, merge, publish,
 12 | // distribute, sublicense, and/or sell copies of the Software, and to
 13 | // permit persons to whom the Software is furnished to do so, subject to
 14 | // the following conditions:
 15 | 
 16 | // The above copyright notice and this permission notice shall be
 17 | // included in all copies or substantial portions of the Software.
 18 | 
 19 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 20 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 21 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 22 | // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 23 | // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 24 | // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 25 | // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 26 | 
 27 | using System;
 28 | using System.ComponentModel;
 29 | using System.Diagnostics.Contracts;
 30 | 
 31 | namespace Experimental.DotNetExtensions
 32 | {
 33 | 
 34 |     /// <summary>
 35 |     /// Factory class for ValueStatePair<T, S> objects
 36 |     /// </summary>
 37 |     public static class ValueStatePair
 38 |     {
 39 |         /// <summary>
 40 |         /// Creates a value-state pair
 41 |         /// </summary>
 42 |         /// <typeparam name="T">The type of the value object.</typeparam>
 43 |         /// <typeparam name="S">The type of the state object.</typeparam>
 44 |         /// <param name="value">The value object to store in the pair.</param>
 45 |         /// <param name="state">The state object to store in the pair.</param>
 46 |         /// <returns>The newly created value-state pair.</returns>
 47 |         public static ValueStatePair<T, S> Create<T, S>(T value, S state)
 48 |         {
 49 |             return new ValueStatePair<T, S>(value, state);
 50 |         }
 51 |     }
 52 |     /// <summary>
 53 |     /// Represents a tuple of a value and state.
 54 |     /// </summary>
 55 |     /// <typeparam name="T">The type of the value object.</typeparam>
 56 |     /// <typeparam name="S">The type of the state object.</typeparam>
 57 |     public struct ValueStatePair<T, S>
 58 |     {
 59 |         /// <summary>
 60 |         /// Constructor
 61 |         /// </summary>
 62 |         /// <param name="value">The value object to store in the pair.</param>
 63 |         /// <param name="state">The state object to store in the pair.</param>
 64 |         public ValueStatePair(T value, S state)
 65 |             : this()
 66 |         {
 67 |             Value = value;
 68 |             State = state;
 69 |         }
 70 | 
 71 |         public T Value { get; private set; }
 72 |         public S State { get; private set; }
 73 |     }
 74 | 
 75 |     /// <summary>
 76 |     /// Encapsulates a propagator transform that combines a mutable state object 
 77 |     /// with a value, usually via closure.
 78 |     /// </summary>
 79 |     /// <typeparam name="S">The type of state object to propagate.</typeparam>
 80 |     /// <typeparam name="T">The type of values included with propagated state.</typeparam>
 81 |     public struct State<S, T>
 82 |     {
 83 |         // Haskell does not require a name for the function "inside" the 
 84 |         // state monad that moves the state along, but we do. Let's call it
 85 |         // a Propagator:
 86 | 
 87 |         /// <summary>
 88 |         /// The content of a State is the propagator function that combines a
 89 |         /// mutable state object with a value.
 90 |         /// </summary>
 91 |         public readonly Func<S, ValueStatePair<T, S>> Propagator;
 92 | 
 93 |         /// <summary>
 94 |         /// Constructor.
 95 |         /// </summary>
 96 |         /// <param name="propagator">The input propagator.</param>
 97 |         public State(Func<S, ValueStatePair<T, S>> propagator)
 98 |             : this()
 99 |         {
100 |             Contract.Requires(null != propagator, "propagator");
101 |             Contract.Ensures(Propagator != null, "Propagator");
102 |             Propagator = propagator;
103 |         }
104 |     }
105 | 
106 |     /// <summary>
107 |     /// Encapsulates a propagator transform that combines a mutable state object 
108 |     /// with a value, usually via closure.
109 |     /// </summary>
110 |     public static class State
111 |     {
112 |         /// <summary>
113 |         /// Produces a State with a trivial propagator: a closure over the given value.
114 |         /// </summary>
115 |         /// <typeparam name="S">The type of state object to propagate.</typeparam>
116 |         /// <typeparam name="T">The type of values included with propagated state.</typeparam>
117 |         /// <param name="value">The value to include with the propagated state.</param>
118 |         /// <returns>A State encapsulating the propagator closure.</returns>
119 |         public static State<S, T> Return<S, T>(T value)
120 |         {
121 |             // value is allowed to be null, but it's better if it's a Maybe (TODO)!
122 |             return new State<S, T>(propagator: s => ValueStatePair.Create(value, s));
123 |         }
124 | 
125 |         // Conventionally, in LINQ, the monadic "return" operator is written "To...,"
126 |         // as in "ToList," "ToArray," etc. These are synonyms for Return.
127 | 
128 |         /// <summary>
129 |         /// Converts a value int a State with a trivial propagator: a closure over the given value.
130 |         /// </summary>
131 |         /// <typeparam name="S">The type of state object to propagate.</typeparam>
132 |         /// <typeparam name="T">The type of values included with propagated state.</typeparam>
133 |         /// <param name="value">The value to include with the propagated state.</param>
134 |         /// <returns>A State encapsulating the propagator closure.</returns>
135 |         public static State<S, T> ToState<S, T>(
136 |             this T value)
137 |         {
138 |             // value is allowed to be null, but it's better if it's a Maybe (TODO)!
139 |             return State.Return<S, T>(value);
140 |         }
141 |         
142 |         /// <summary>
143 |         /// Produces a State that chains an input propagator through a transform
144 |         /// that produces a second propagator.
145 |         /// </summary>
146 |         /// <typeparam name="S">The type of state object to propagate through the chain.</typeparam>
147 |         /// <typeparam name="T">The type of value included with propagated state in the first link of the chain.</typeparam>
148 |         /// <typeparam name="U">The type of value included with propagated state in the second link of the chain.</typeparam>
149 |         /// <param name="st">A State whose propagator includes values of type T.</param>
150 |         /// <param name="t2su">A function that converts values of type T to States whose propagators include values of type U.</param>
151 |         /// <returns>A State whose propagator includes values of type U.</returns>
152 |         public static State<S, U> Bind<S, T, U>(
153 |             this State<S, T> st,
154 |             Func<T, State<S, U>> t2su)
155 |         {
156 |             Contract.Requires(null != st.Propagator, "mt.Propagator");
157 |             Contract.Requires(null != t2su, "t2mu");
158 | 
159 |             var self = st;
160 | 
161 |             return new State<S, U>(
162 |                 propagator: s =>
163 |                 {
164 |                     var intermediate = self.Propagator(s);
165 |                     var tNuValue = intermediate.Value;
166 |                     var sNuState = intermediate.State;
167 | 
168 |                     return t2su(tNuValue).Propagator(sNuState);
169 |                 });
170 |         }
171 | 
172 |         #region SelectMany Operator
173 | 
174 |         // This operator is implemented only to satisfy C#'s LINQ comprehension syntax.  
175 |         // The name "SelectMany" is confusing as there is only one value to "select".
176 |         [EditorBrowsable(EditorBrowsableState.Never)]
177 |         public static State<S, U> SelectMany<S, T, U>(
178 |             this State<S, T> mt,
179 |             Func<T, State<S, U>> t2mu)
180 |         {
181 |             Contract.Requires(null != mt.Propagator, "mt.Propagator");
182 |             Contract.Requires(null != t2mu, "t2mu");
183 | 
184 |             return mt.Bind(t2mu);
185 |         }
186 | 
187 |         // This operator is implemented only to satisfy C#'s LINQ comprehension syntax.  
188 |         // The name "SelectMany" is confusing as there is only one value to "select".
189 |         [EditorBrowsable(EditorBrowsableState.Never)]
190 |         public static State<S, V> SelectMany<S, T, U, V>(
191 |             this State<S, T> mt,
192 |             Func<T, State<S, U>> t2mu,
193 |             Func<T, U, V> t2u2v)
194 |         {
195 |             Contract.Requires(null != t2mu, "t2mu");
196 |             Contract.Requires(null != t2u2v, "t2u2v");
197 | 
198 |             return mt.Bind(t => t2mu(t).Bind(u => t2u2v(t, u).ToState<S, V>()));
199 |         }
200 | 
201 |         #endregion
202 |     }
203 | }


--------------------------------------------------------------------------------
/iSynapticSubset/TrySelector.cs:
--------------------------------------------------------------------------------
 1 | // The MIT License
 2 | 
 3 | // Portions Copyright (c) 2011 Jordan E. Terrell, licensed to 
 4 | // Microsoft Corporation under the MIT license (copied below).
 5 | // 
 6 | // Portions Copyright (c) 2011 Microsoft Corporation
 7 | 
 8 | // Permission is hereby granted, free of charge, to any person obtaining
 9 | // a copy of this software and associated documentation files (the
10 | // "Software"), to deal in the Software without restriction, including
11 | // without limitation the rights to use, copy, modify, merge, publish,
12 | // distribute, sublicense, and/or sell copies of the Software, and to
13 | // permit persons to whom the Software is furnished to do so, subject to
14 | // the following conditions:
15 | 
16 | // The above copyright notice and this permission notice shall be
17 | // included in all copies or substantial portions of the Software.
18 | 
19 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22 | // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
23 | // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
24 | // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
25 | // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 | 
27 | using System;
28 | using System.Collections.Generic;
29 | using System.Linq;
30 | using System.Text;
31 | 
32 | namespace Experimental.DotNetExtensions.iSynaptic
33 | {
34 |     public delegate bool TrySelector<TResult>(out TResult result);
35 |     public delegate bool TrySelector<in T, TResult>(T input, out TResult result);
36 | }
37 | 


--------------------------------------------------------------------------------
/iSynapticSubset/Unit.cs:
--------------------------------------------------------------------------------
 1 | // The MIT License
 2 | 
 3 | // Portions Copyright (c) 2011 Jordan E. Terrell, licensed to 
 4 | // Microsoft Corporation under the MIT license (copied below).
 5 | // 
 6 | // Portions Copyright (c) 2011 Microsoft Corporation
 7 | 
 8 | // Permission is hereby granted, free of charge, to any person obtaining
 9 | // a copy of this software and associated documentation files (the
10 | // "Software"), to deal in the Software without restriction, including
11 | // without limitation the rights to use, copy, modify, merge, publish,
12 | // distribute, sublicense, and/or sell copies of the Software, and to
13 | // permit persons to whom the Software is furnished to do so, subject to
14 | // the following conditions:
15 | 
16 | // The above copyright notice and this permission notice shall be
17 | // included in all copies or substantial portions of the Software.
18 | 
19 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22 | // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
23 | // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
24 | // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
25 | // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 | 
27 | using System;
28 | 
29 | namespace Experimental.DotNetExtensions.iSynaptic
30 | {
31 |     public struct Unit : IEquatable<Unit>
32 |     {
33 |         public bool Equals(Unit other)
34 |         {
35 |             return true;
36 |         }
37 | 
38 |         public override bool Equals(object obj)
39 |         {
40 |             if (ReferenceEquals(obj, null))
41 |                 return false;
42 | 
43 |             return obj is Unit;
44 |         }
45 | 
46 |         public override int GetHashCode()
47 |         {
48 |             return 0;
49 |         }
50 | 
51 |         public static bool operator ==(Unit left, Unit right)
52 |         {
53 |             return left.Equals(right);
54 |         }
55 | 
56 |         public static bool operator !=(Unit left, Unit right)
57 |         {
58 |             return !(left == right);
59 |         }
60 |     }
61 | }


--------------------------------------------------------------------------------