Differential & Integral Calculus (lim, ∂, ∫) [Video Lectures]

The Calculus is an important branch of mathematics. In this post we'll go through the lectures on differential and integral calculus, which are one of the hard problems students face during their college.

The "Derivative" is a measure of how a function changes as its input changes.Loosely speaking, a derivative can be thought of as how much one quantity is changing in response to changes in some other quantity; for example, the derivative of the position of a moving object with respect to time is the object's instantaneous velocity. Or how fast the temperature of a room is changing with respect to time. The derivative of a function at a chosen input value describes the best linear approximation of the function near that input value. For a real-valued function of a single real variable, the derivative at a point equals the slope of the tangent line to the graph of the function at that point. In higher dimensions, the derivative of a function at a point is a linear transformation called the linearization.


Understanding "Limits" is important before starting with derivatives or integration. Informally, a function f assigns an output f(x) to every input x. The function has a limit L at an input p if f(x) is "close" to L whenever x is "close" to p. In other words, f(x) becomes closer and closer to L as x moves closer and closer to p. More specifically, when f is applied to each input sufficiently close to p, the result is an output value that is arbitrarily close to L. If the inputs "close" to p are taken to values that are very different, the limit is said to not exist.

Above stuff seems confusing, let's take a deeper look at these concepts using the video lectures:



A Big Thanks to UCLA for posting these lectures.

Machine Learning - Tutorial & Stanford Lecture Videos

What is Machine Learning?
A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E. - Tom M. Mitchell (1997).

Prerequisites
Following are the recommended prerequisites for this course:

• Normal distribution
• Gaussian function
• Basic probability
  
• Derivatives
  

Lecture handouts

cs229-notes1.pdf	Linear Regression, Classification and logistic regression, Generalized Linear Models
cs229-notes2.pdf	Generative Learning algorithms
cs229-notes3.pdf	Support Vector Machines
cs229-notes4.pdf	Learning Theory
cs229-notes5.pdf	Regularization and model selection
cs229-notes6.pdf	The perceptron and large margin classifiers
cs229-notes7a.pdf	The k-means clustering algorithm
cs229-notes7b.pdf	Mixtures of Gaussians and the EM algorithm
cs229-notes8.pdf	The EM algorithm
cs229-notes9.pdf	Factor analysis
cs229-notes10.pdf	Principal components analysis
cs229-notes11.pdf	Independent Components Analysis
cs229-notes12.pdf	Reinforcement Learning and Control

Machine Learning - Standford University Lectures

• Lecture 1
  


• Lecture 2
  


• Lecture 3
  


• Lecture 4
  


• Lecture 5
  


• Lecture 6
  


• Lecture 7
  


• Lecture 8
  


• Lecture 9
  


• Lecture 10
  


• Lecture 11
  


• Lecture 12
  


• Lecture 13
  


• Lecture 14
  


• Lecture 15
  


• Lecture 16
  


• Lecture 17
  


• Lecture 18
  


• Lecture 19
  


• Lecture 20
  

A Big thanks to the Standford University for posting these lectures.

How To: Execute and Save SSRS Report using C#

It is often required to execute a SSRS report from within C# and save it in the required file format like PDF, XLS etc.

SQL Server Reporting Services (SSRS) exposes two web services using which we can execute a report and save it in the required file format. The two web services are:

• Reporting Service 2005 : http://[SERVER]/reportserver/reportservice2005.asmx
  
• Report Execution Service : http://[SERVER]/reportserver/reportexecution2005.asmx
  

Add the above two web services as "Web Reference" to your project with the following namespace RS2005 and RE2005:



Use the C# code below to execute and save the report:

      public static void SaveReport()
    {

        RS2005.ReportingService2005 rs;
        RE2005.ReportExecutionService rsExec;

        // Create a new proxy to the web service
        rs = new RS2005.ReportingService2005();
        rsExec = new RE2005.ReportExecutionService();

        // Authenticate to the Web service using Windows credentials
        rs.Credentials = System.Net.CredentialCache.DefaultCredentials;
        rsExec.Credentials = System.Net.CredentialCache.DefaultCredentials;

        rs.Url = "http://<SERVER>/reportserver/reportservice2005.asmx";
        rsExec.Url = "http://<SERVER>/reportserver/reportexecution2005.asmx";

        string historyID = null;
        string deviceInfo = null;
        string format = "EXCEL";
        Byte[] results;
        string encoding = String.Empty;
        string mimeType = String.Empty;
        string extension = String.Empty;
        RE2005.Warning[] warnings = null;
        string[] streamIDs = null;

        // Path of the Report - XLS, PDF etc.
        string fileName = @"c:\samplereport.xls";
        // Name of the report - Please note this is not the RDL file.
        string _reportName = @"/Marketing_Report";
        string _historyID = null;
        bool _forRendering = false;
        RS2005.ParameterValue[] _values = null;
        RS2005.DataSourceCredentials[] _credentials = null;
        RS2005.ReportParameter[] _parameters = null;

        try
        {
            _parameters = rs.GetReportParameters(_reportName, _historyID, _forRendering, _values, _credentials);
            RE2005.ExecutionInfo ei = rsExec.LoadReport(_reportName, historyID);
            RE2005.ParameterValue[] parameters = new RE2005.ParameterValue[1];

            if (_parameters.Length > 0)
            {
                //parameters[0] = new RE2005.ParameterValue();
                //parameters[0].Label = "";
                //parameters[0].Name  = "";
                //parameters[0].Value = "";
            }
            rsExec.SetExecutionParameters(parameters, "en-us");

            results = rsExec.Render(format, deviceInfo,
                      out extension, out encoding,
                      out mimeType, out warnings, out streamIDs);

            using (FileStream stream = File.OpenWrite(fileName))
            {
                stream.Write(results, 0, results.Length);
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }

    }

Following output file formats are available: XML, CSV, IMAGE, PDF, EXCEL, WORD, HTML 4.0 and MHTML

Hope this helps!

JSON to XML and XML to JSON Converter in C#

What is JSON?

JSON, short for JavaScript Object Notation, is a lightweight computer data interchange format. It is a text-based, human-readable format for representing simple data structures and associative arrays (called objects). The JSON format was originally specified in RFC 4627 by Douglas Crockford. The official Internet media type for JSON is application/json. The JSON filename extension is .json. More information on JSON can be found at http://www.json.org

Some examples of XML and its equivalent JSON as given below:
XML: <xx yy='nn'><mm>zzz</mm></xx>
JSON: { "xx": {"yy":"nn","mm":"zzz"}}

XML: <xx yy='nn'><mm>zzz</mm><mm>aaa</mm></xx>
JSON: { "xx": {"yy":"nn", "mm":["zzz","aaa" ] } }

XML: <xx><mm>zzz</mm>some text</xx>
JSON: { "xx": {"mm":"zzz", "value":"some text"} }

XML: <xx value='yyy'>some text<mm>zzz</mm>more text</xx>
JSON: { "xx": {"mm":"zzz", "value":[ "yyy", "some text", "more text" ] } }

JSON to XML and XML to JSON Converter
James Newton-King has created an excellent library for JSON conversion in C#. The library has following features:

• LINQ to JSON
• The JsonSerializer for quickly converting your .NET objects to JSON and back again
• Json.NET can optionally produce well formatted, indented JSON for debugging or display
• Attributes like JsonIgnore and JsonProperty can be added to a class to customize how a class is serialized
• Ability to convert JSON to and from XML
• Supports multiple platforms: .NET, Silverlight and the Compact Framework

You can download the JSON C# library here. More information about the JSON Utilities library can be found at http://james.newtonking.com/projects/json-net.aspx.
Hats off James, this is an excellent work!

MS Exchange 2010 Web service Helper Class in C#

I have created a helper class for interfacing with MS Exchange 2010 Web Service. This class does not include all the methods exposed by the web service, but includes the major ones.

#region References

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;

#endregion References

namespace Exchange2007Manager
{
   class ExchangeHelper
   {
       static ExchangeServiceBinding service = new ExchangeServiceBinding();

       /********************************************************************
         * INITIALIZE MS EXCHANGE WEB SERVICE
         ********************************************************************/
       public static void InitMSExchange(String userName, String domain, String password)
       {

           service.RequestServerVersionValue = new RequestServerVersion();
           service.RequestServerVersionValue.Version = ExchangeVersionType.Exchange2010;

           ServicePointManager.ServerCertificateValidationCallback = delegate(
               Object obj, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
           {
               // trust any certificate
               return true;
           };

           // enable compression
           service.EnableDecompression = true;
           // your email account userName, password and the windows domain
           service.Credentials = new NetworkCredential(userName, password, domain);
           service.Url = @"https://server.com/EWS/exchange.asmx";
       }


       /********************************************************************
         * GET UNREAD ITEMS FROM A FOLDER
         ********************************************************************/
       public static List<ItemType> GetUnReadItems(String folderName)
       {
           // serialize response2  object for diagnostics purposes here
           List<ItemType> lst = new List<ItemType>();
           int count = GetUnreadFolderItemsCount(folderName);

           if (count != 0)
           {
               lst = GetUnReadFolderItems(folderName);
           }

           return lst;
       }


       /********************************************************************
         * MARK ITEM AS READ
         ********************************************************************/
       public static bool SetReadStatus(ItemIdType item)
       {
           SetItemFieldType setField = new SetItemFieldType();
           PathToUnindexedFieldType path = new PathToUnindexedFieldType();

           MessageType message = new MessageType();
           message.IsRead = true;
           message.IsReadSpecified = true;
           setField.Item1 = message;
           path.FieldURI = UnindexedFieldURIType.messageIsRead;

           setField.Item = path;
           ItemChangeType[] updatedItems = new ItemChangeType[1];
           updatedItems[0] = new ItemChangeType();
           updatedItems[0].Updates = new ItemChangeDescriptionType[1];
           updatedItems[0].Updates[0] = setField;

           ItemChangeDescriptionType[] updates = new ItemChangeDescriptionType[1];
           updates[0] = new ItemChangeDescriptionType();
           updates[0].Item = path;

           updatedItems[0].Item = new ItemIdType();
           ((ItemIdType)updatedItems[0].Item).Id = item.Id;
           ((ItemIdType)updatedItems[0].Item).ChangeKey = item.ChangeKey;
           UpdateItemType request = new UpdateItemType();
           request.ItemChanges = updatedItems;
           request.ConflictResolution = ConflictResolutionType.AutoResolve;
           request.MessageDisposition = MessageDispositionType.SaveOnly;
           request.MessageDispositionSpecified = true;

           UpdateItemResponseType response = service.UpdateItem(request);

           if (response.ResponseMessages.Items[0].ResponseClass !=
                                ResponseClassType.Success)
               return false;
           else
               return true;
       }


       /********************************************************************
         * GET UNREAD ITEM COUNT FROM A FOLDER
         ********************************************************************/
       public static int GetUnreadFolderItemsCount(String folderName)
       {
           int unReadCount = -1;
           // Identify the folder properties to return.
           FolderResponseShapeType properties = new FolderResponseShapeType();
           PathToUnindexedFieldType ptuft = new PathToUnindexedFieldType();
           ptuft.FieldURI = UnindexedFieldURIType.folderManagedFolderInformation;
           PathToUnindexedFieldType[] ptufts = new PathToUnindexedFieldType[1] { ptuft };
           properties.AdditionalProperties = ptufts;
           properties.BaseShape = DefaultShapeNamesType.AllProperties;

           // Form the get folder request.
           BaseFolderIdType p_folder = FindFolderID(folderName);

           GetFolderType request = new GetFolderType();
           request.FolderIds = new BaseFolderIdType[1] { p_folder };
           request.FolderShape = properties;

           // Send the request and get the response.
           GetFolderResponseType response = service.GetFolder(request);

           ArrayOfResponseMessagesType aormt = response.ResponseMessages;
           ResponseMessageType[] rmta = aormt.Items;
           foreach (ResponseMessageType rmt in rmta)
           {
               if (rmt.ResponseClass == ResponseClassType.Error)
               {
                   throw new Exception(rmt.MessageText);
               }
               else
               {
                   FolderInfoResponseMessageType firmt;
                   firmt = (rmt as FolderInfoResponseMessageType);
                   BaseFolderType[] folders = firmt.Folders;

                   foreach (BaseFolderType rfolder in folders)
                   {
                       if (rfolder is FolderType)
                       {
                           FolderType myFolder;
                           myFolder = (rfolder as FolderType);
                           if (myFolder.UnreadCountSpecified)
                           {
                               unReadCount = myFolder.UnreadCount;
                           }
                       }
                   }
               }
           }
           return unReadCount;
       }

       /********************************************************************
         * FIND FOLDER ID FOR THE NAME GIVEN
         ********************************************************************/
       public static FolderIdType FindFolderID(String folderName)
       {
           DistinguishedFolderIdType objSearchRootFolder = new DistinguishedFolderIdType();
           objSearchRootFolder.Id = DistinguishedFolderIdNameType.msgfolderroot;

           FindFolderType requestFindFolder = new FindFolderType();
           requestFindFolder.Traversal = FolderQueryTraversalType.Deep;
           requestFindFolder.ParentFolderIds = new DistinguishedFolderIdType[] { objSearchRootFolder };
           requestFindFolder.FolderShape = new FolderResponseShapeType();
           requestFindFolder.FolderShape.BaseShape = DefaultShapeNamesType.IdOnly;

           //Search filter definition
           requestFindFolder.Restriction = new RestrictionType();

           #region Contains expression

           ContainsExpressionType objContainsExpression = new ContainsExpressionType();
           objContainsExpression.ContainmentMode = ContainmentModeType.FullString;
           objContainsExpression.ContainmentModeSpecified = true;
           objContainsExpression.ContainmentComparison = ContainmentComparisonType.Exact;
           objContainsExpression.ContainmentComparisonSpecified = true;

           PathToUnindexedFieldType objFieldFolderName = new PathToUnindexedFieldType();
           objFieldFolderName.FieldURI = UnindexedFieldURIType.folderDisplayName;
           objContainsExpression.Item = objFieldFolderName;

           objContainsExpression.Constant = new ConstantValueType();
           objContainsExpression.Constant.Value = folderName;

           #endregion Contains expression

           requestFindFolder.Restriction.Item = objContainsExpression;

           FindFolderResponseType objFindFolderResponse =
               service.FindFolder(requestFindFolder);

           if (objFindFolderResponse.ResponseMessages.Items.Length == 0)
               return null;

           foreach (ResponseMessageType responseMsg in
               objFindFolderResponse.ResponseMessages.Items)
           {
               if (responseMsg.ResponseClass == ResponseClassType.Success)
               {
                   FindFolderResponseMessageType objFindResponse =
                       responseMsg as FindFolderResponseMessageType;
                   foreach (
                       BaseFolderType objFolderType in objFindResponse.RootFolder.Folders)
                   {
                       return objFolderType.FolderId;
                   }
               }
           }
           return null;
       }

       /********************************************************************
         * GET UNREAD FOLDER ITEMS
         ********************************************************************/
       private static List<ItemType> GetUnReadFolderItems(String folderName)
       {

           FindItemType findRequest = new FindItemType();
           findRequest.ItemShape = new ItemResponseShapeType();

           ItemResponseShapeType itemProperties = new ItemResponseShapeType();
           // Use the Default shape for the response.            
           itemProperties.BaseShape = DefaultShapeNamesType.AllProperties;
           itemProperties.BodyType = BodyTypeResponseType.Text;
           itemProperties.BodyTypeSpecified = true;

           RestrictionType restrict = new RestrictionType();
           IsEqualToType isEqTo = new IsEqualToType();
           PathToUnindexedFieldType ptuift = new PathToUnindexedFieldType();
           ptuift.FieldURI = UnindexedFieldURIType.messageIsRead;
           isEqTo.Item = ptuift;
           FieldURIOrConstantType msgReadYes = new FieldURIOrConstantType();
           msgReadYes.Item = new ConstantValueType();
           (msgReadYes.Item as ConstantValueType).Value = "0";  //1= boolean yes; so you'll get the list of read messages
           isEqTo.FieldURIOrConstant = msgReadYes;
           restrict.Item = isEqTo;
           findRequest.Restriction = restrict;

           findRequest.ItemShape = itemProperties;

           //Set the inbox as the parent search folder in search attachementRequest.
           BaseFolderIdType p_folder = FindFolderID(folderName);
           findRequest.ParentFolderIds = new BaseFolderIdType[] { p_folder };
           findRequest.Traversal = ItemQueryTraversalType.Shallow;


           // Perform the inbox search
           FindItemResponseType response = service.FindItem(findRequest);
           FindItemResponseMessageType responseMessage = response.ResponseMessages.Items[0] as FindItemResponseMessageType;
           if (responseMessage.ResponseCode != ResponseCodeType.NoError)
           {
               throw new Exception(responseMessage.MessageText);
           }
           else
           {

               // find items details
               GetItemResponseType response2 = service.GetItem(new GetItemType
               {
                   ItemIds = ((response as FindItemResponseType)
                               .ResponseMessages
                               .Items
                               .Select(n => n as FindItemResponseMessageType)
                               .Select(n => n.RootFolder).Single().Item as ArrayOfRealItemsType)
                               .Items
                               .Select(n => new ItemIdType { Id = n.ItemId.Id })
                               .ToArray()
                   ,
                   ItemShape = new ItemResponseShapeType
                   {
                       BaseShape = DefaultShapeNamesType.Default,
                       BodyType = BodyTypeResponseType.Text
                   }
               });

               List<ItemType> messages = new List<ItemType>();

               for (int j = 0; j < response2.ResponseMessages.Items.Count(); j++)
                   messages.Add(((ItemInfoResponseMessageType)response2.ResponseMessages.Items[j]).Items.Items[0]);


               return messages;
           }
       }

       /********************************************************************
         * GET ITEM FOR ID SUPPLIED
         ********************************************************************/
       private static ItemType GetItemForID(String id)
       {
           ItemIdType iit = new ItemIdType();
           iit.Id = id;

           GetItemType git = new GetItemType();
           git.ItemIds = new ItemIdType[] { iit };
           git.ItemShape = new ItemResponseShapeType();
           git.ItemShape.BaseShape = DefaultShapeNamesType.AllProperties;

           GetItemResponseType girt = service.GetItem(git);

           if (girt.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Error)
               throw new Exception(String.Format("Unable to get message item and Mime Content\r\n{0}\r\n{1}",
                                                                              girt.ResponseMessages.Items[0].ResponseCode,
                                                                              girt.ResponseMessages.Items[0].MessageText));
           ItemType message = null;
           if (girt.ResponseMessages.Items.Count() > 0)
               message = (((ItemInfoResponseMessageType)girt.ResponseMessages.Items[0]).Items.Items[0]);

           return message;
       }

       /********************************************************************
         * REPLY AN EMAIL WITH THE ITEMID AND THE REPLYBODY
         ********************************************************************/
       private static void Reply(String itemID, String replyBody)
       {

           ItemIdType iit = new ItemIdType();
           iit.Id = itemID;

           CreateItemType request = new CreateItemType();
           request.MessageDisposition = MessageDispositionType.SendAndSaveCopy;
           request.MessageDispositionSpecified = true;
           request.SavedItemFolderId = new TargetFolderIdType();
           request.SavedItemFolderId.Item = new DistinguishedFolderIdType();
           (request.SavedItemFolderId.Item as DistinguishedFolderIdType).Id = DistinguishedFolderIdNameType.sentitems;

           ReplyToItemType reply = new ReplyToItemType();
           // Id of the message to which to reply
           reply.ReferenceItemId = iit;
           reply.NewBodyContent = new BodyType();
           reply.NewBodyContent.BodyType1 = BodyTypeType.HTML;
           reply.NewBodyContent.Value = replyBody;

           // Set additional properties on the reply object if you wish...
           CreateItemResponseType response = service.CreateItem(request);

           if (response.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success)
           {
               // Success, the reply was sent and saved in the SentItems folder.
               // NB: Since sending a message is an asynchronous operation, NO ITEM ID IS RETURNED.
               // To obtain the Id of the reply message, set the MessageDisposition flag above to SaveOnly.
               // The Id can be found in the response:
               // ItemIdType replyId = ((ItemInfoResponseMessageType)response.ResponseMessages.Items[0]).Items.Items[0].ItemId;
               // You can then call SendItem to send the message.
           }
           else
           {
               // An error has occurred
           }
       }
   }
}